Arboricx bundle format 1.1

We don't need SHA verification or Merkle dags in our transport bundle. Content
stores can handle both bundle and term verification and hashing.

src/Main.hs

@@ -1,6 +1,6 @@
 module Main where
 
-import ContentStore (initContentStoreWithPath, loadEnvironment, loadTerm, resolveExportTarget)
+import ContentStore (initContentStoreWithPath, loadEnvironment, loadTerm, loadTree, resolveExportTarget)
 import System.Exit (die)
 import Server (runServerWithPath)
 import Eval (evalTricu, evalTricuWithStore, mainResult, result)
@@ -8,7 +8,7 @@ import FileEval (evaluateFileWithContext, evaluateFileWithStore, compileFile)
 import Parser (parseTricu)
 import REPL (repl)
 import Research (T, EvaluatedForm(..), Env, formatT, exportDag)
-import Wire (exportNamedBundle, defaultExportNames, importBundle)
+import Wire (buildBundle, encodeBundle, importBundle, defaultExportNames, Bundle(..))
 
 import Control.Monad (foldM, unless, when)
 import Data.Text (unpack, pack)
@@ -17,7 +17,9 @@ import Data.Version (showVersion)
 import Paths_tricu (version)
 import Options.Applicative
 
+import qualified Data.ByteString as BS
 import qualified Data.ByteString.Lazy as BL
+import qualified Data.Sequence as Seq
 import Database.SQLite.Simple (Connection, close)
 
 import qualified Data.Map as Map
@@ -36,10 +38,10 @@ data TricuArgs
       , evalDb      :: Maybe FilePath
       }
   | ArboricxCompile
-      { compileInput  :: FilePath
-      , compileOutput :: FilePath
-      , compileNames  :: [String]
-      , compileDb     :: Maybe FilePath
+      { compileInput   :: FilePath
+      , compileOutput  :: FilePath
+      , compileNames   :: [String]
+      , compileDb      :: Maybe FilePath
       }
   | ArboricxImport
       { importFile :: FilePath
@@ -292,9 +294,9 @@ runImport opts = do
   when (null file) $ die "tricu arboricx import: input file is required"
   withContentStore (importDb opts) $ \conn -> do
     bundleData <- BL.readFile file
-    roots <- importBundle conn (BL.toStrict bundleData)
+    roots <- map T.unpack <$> importBundle conn (BL.toStrict bundleData)
     putStrLn $ "Imported " ++ show (length roots) ++ " root(s):"
-    mapM_ (\r -> putStrLn $ "  " ++ unpack r) roots
+    mapM_ (\r -> putStrLn $ "  " ++ r) roots
 
 runExport :: TricuArgs -> IO ()
 runExport opts =
@@ -310,18 +312,24 @@ runExportBundle opts = do
   when (null out)     $ die "tricu arboricx export: --output is required"
   when (null targets) $ die "tricu arboricx export: at least one --target is required"
   withContentStore (exportDb opts) $ \conn -> do
-    hashes <- mapM (\t -> do
+    terms <- mapM (\t -> do
       (h, _) <- resolveExportTarget conn t
-      return h) targets
+      maybeTree <- loadTree conn h
+      case maybeTree of
+        Nothing -> die $ "Term not found in store: " ++ t
+        Just tree -> return tree) targets
     let expNames = if null names
-          then defaultExportNames (length hashes)
+          then defaultExportNames (length terms)
           else map T.pack names
-    when (length expNames /= length hashes) $
+    when (length expNames /= length terms) $
       die "tricu arboricx export: number of --name values must match number of TARGETs"
-    let exports = zip expNames hashes
-    bundleData <- exportNamedBundle conn exports
+    let namedTerms = zip expNames terms
+        bundle = buildBundle namedTerms
+        bundleData = encodeBundle bundle
     BL.writeFile out (BL.fromStrict bundleData)
-    putStrLn $ "Exported bundle with " ++ show (length exports) ++ " export(s) to " ++ out
+    putStrLn $ "Exported bundle with " ++ show (length namedTerms) ++ " export(s) to " ++ out
+    putStrLn $ "  nodes: " ++ show (Seq.length (bundleNodes bundle))
+    putStrLn $ "  size: " ++ show (BS.length bundleData) ++ " bytes"
 
 runExportDag :: TricuArgs -> IO ()
 runExportDag opts = do