trellis 2.0.6 → 2.0.8

package/dist/{index-1j1anhmr.js → index-s603ev6w.js}

@@ -1,7 +1,8 @@
 // @bun
 import {
-  EAVStore
-} from "./index-gkvhzm9f.js";
+  EAVStore,
+  init_eav_store
+} from "./index-5bhe57y9.js";
 import {
   BlobStore,
   addCriterion,
@@ -20,6 +21,14 @@ import {
   diffOpRange,
   getActiveIssues,
   getIssue,
+  init_blob_store,
+  init_branch,
+  init_checkpoint,
+  init_decompose,
+  init_diff,
+  init_issue,
+  init_merge,
+  init_milestone,
   listBranches,
   listCheckpoints,
   listIssues,
@@ -37,17 +46,23 @@ import {
   triageIssue,
   unblockIssue,
   updateIssue
-} from "./index-3s0eak0p.js";
+} from "./index-3ejh8k6v.js";
 import {
   getDecision,
   getDecisionChain,
+  init_decisions,
   queryDecisions,
   recordDecision
-} from "./index-8pce39mh.js";
+} from "./index-65z0xfjw.js";
 import {
   DEFAULT_CONFIG,
-  createVcsOp
-} from "./index-fd4e26s4.js";
+  createVcsOp,
+  init_ops,
+  init_types
+} from "./index-v9b4hqa7.js";
+import {
+  __esm
+} from "./index-a76rekgs.js";
 
 // src/watcher/fs-watcher.ts
 import { watch } from "fs";
@@ -81,10 +96,23 @@ class FileWatcher {
   constructor(config) {
     this.config = config;
   }
-  async scan() {
+  async scan(opts) {
     const events = [];
+    opts?.onProgress?.({
+      phase: "discovering",
+      current: 0,
+      total: 0,
+      message: "Discovering existing files\u2026"
+    });
     const entries = await this.walkDir(this.config.rootPath);
-    for (const absPath of entries) {
+    opts?.onProgress?.({
+      phase: "hashing",
+      current: 0,
+      total: entries.length,
+      message: `Hashing ${entries.length} existing files\u2026`
+    });
+    for (let i = 0;i < entries.length; i++) {
+      const absPath = entries[i];
       const relPath = relative(this.config.rootPath, absPath);
       if (shouldIgnore(relPath, this.config.ignorePatterns))
         continue;
@@ -100,7 +128,21 @@ class FileWatcher {
           timestamp: new Date().toISOString()
         });
       } catch {}
+      if ((i + 1) % 25 === 0 || i === entries.length - 1) {
+        opts?.onProgress?.({
+          phase: "hashing",
+          current: i + 1,
+          total: entries.length,
+          message: `Hashed ${i + 1}/${entries.length} files`
+        });
+      }
     }
+    opts?.onProgress?.({
+      phase: "done",
+      current: events.length,
+      total: events.length,
+      message: `Discovered ${events.length} trackable files`
+    });
     return events;
   }
   start() {
@@ -206,37 +248,10 @@ class FileWatcher {
     return results;
   }
 }
+var init_fs_watcher = () => {};
 
 // src/watcher/ingestion.ts
 import { extname } from "path";
-var EXT_LANGUAGE = {
-  ".ts": "typescript",
-  ".tsx": "typescript",
-  ".js": "javascript",
-  ".jsx": "javascript",
-  ".py": "python",
-  ".rs": "rust",
-  ".go": "go",
-  ".rb": "ruby",
-  ".java": "java",
-  ".c": "c",
-  ".cpp": "cpp",
-  ".h": "c",
-  ".hpp": "cpp",
-  ".cs": "csharp",
-  ".swift": "swift",
-  ".kt": "kotlin",
-  ".md": "markdown",
-  ".json": "json",
-  ".yaml": "yaml",
-  ".yml": "yaml",
-  ".toml": "toml",
-  ".html": "html",
-  ".css": "css",
-  ".scss": "scss",
-  ".vue": "vue",
-  ".svelte": "svelte"
-};
 function detectLanguage(filePath) {
   const ext = extname(filePath).toLowerCase();
   return EXT_LANGUAGE[ext];
@@ -294,25 +309,40 @@ class Ingestion {
     return this.lastOpHash;
   }
 }
-
-// src/engine.ts
-import {
-  existsSync,
-  mkdirSync,
-  readFileSync,
-  writeFileSync,
-  copyFileSync
-} from "fs";
-import { readFile as readFile2 } from "fs/promises";
-import { join as join2, dirname } from "path";
+var EXT_LANGUAGE;
+var init_ingestion = __esm(() => {
+  init_ops();
+  EXT_LANGUAGE = {
+    ".ts": "typescript",
+    ".tsx": "typescript",
+    ".js": "javascript",
+    ".jsx": "javascript",
+    ".py": "python",
+    ".rs": "rust",
+    ".go": "go",
+    ".rb": "ruby",
+    ".java": "java",
+    ".c": "c",
+    ".cpp": "cpp",
+    ".h": "c",
+    ".hpp": "cpp",
+    ".cs": "csharp",
+    ".swift": "swift",
+    ".kt": "kotlin",
+    ".md": "markdown",
+    ".json": "json",
+    ".yaml": "yaml",
+    ".yml": "yaml",
+    ".toml": "toml",
+    ".html": "html",
+    ".css": "css",
+    ".scss": "scss",
+    ".vue": "vue",
+    ".svelte": "svelte"
+  };
+});
 
 // src/garden/cluster.ts
-var FILE_OP_KINDS = new Set([
-  "vcs:fileAdd",
-  "vcs:fileModify",
-  "vcs:fileDelete",
-  "vcs:fileRename"
-]);
 function isFileOp(op) {
   return FILE_OP_KINDS.has(op.kind);
 }
@@ -330,171 +360,181 @@ function generateClusterId(prefix, ops) {
   const hash = ops[0]?.hash?.slice(0, 8) ?? "unknown";
   return `cluster:${prefix}-${hash}`;
 }
-var contextSwitchDetector = {
-  name: "context-switch",
-  detect(ops, milestonedOpHashes) {
-    const fileOps = ops.filter((o) => isFileOp(o) && !milestonedOpHashes.has(o.hash));
-    if (fileOps.length < 2)
-      return [];
-    const groups = [];
-    let currentGroup = [];
-    let currentFiles = new Set;
-    for (const op of fileOps) {
-      const opFile = op.vcs?.filePath;
-      if (!opFile)
-        continue;
-      const opDir = opFile.split("/").slice(0, -1).join("/") || ".";
-      if (currentGroup.length === 0) {
-        currentGroup.push(op);
-        currentFiles.add(opDir);
-        continue;
-      }
-      const currentDirs = [...currentFiles];
-      const hasOverlap = currentDirs.some((d) => opDir.startsWith(d) || d.startsWith(opDir) || d === opDir);
-      if (hasOverlap) {
-        currentGroup.push(op);
-        currentFiles.add(opDir);
-      } else {
-        if (currentGroup.length > 0) {
-          groups.push(currentGroup);
-        }
-        currentGroup = [op];
-        currentFiles = new Set([opDir]);
+function detectClusters(ops, milestonedOpHashes, detectors = defaultDetectors) {
+  const seen = new Set;
+  const results = [];
+  for (const detector of detectors) {
+    const clusters = detector.detect(ops, milestonedOpHashes);
+    for (const cluster of clusters) {
+      if (!seen.has(cluster.id)) {
+        seen.add(cluster.id);
+        results.push(cluster);
       }
     }
-    if (currentGroup.length > 0) {
-      groups.push(currentGroup);
-    }
-    const clusters = [];
-    for (let i = 0;i < groups.length - 1; i++) {
-      const group = groups[i];
-      if (group.length < 2)
-        continue;
-      clusters.push({
-        id: generateClusterId("ctx", group),
-        ops: group,
-        firstOp: group[0].hash,
-        lastOp: group[group.length - 1].hash,
-        affectedFiles: extractFiles(group),
-        affectedSymbols: [],
-        estimatedIntent: "",
-        createdAt: group[0].timestamp,
-        abandonedAt: group[group.length - 1].timestamp,
-        status: "abandoned",
-        detectedBy: "context-switch"
-      });
-    }
-    return clusters;
   }
-};
-var revertDetector = {
-  name: "revert",
-  detect(ops, milestonedOpHashes) {
-    const clusters = [];
-    const hashHistory = new Map;
-    for (let i = 0;i < ops.length; i++) {
-      const op = ops[i];
-      if (!isFileOp(op) || !op.vcs?.filePath || !op.vcs?.contentHash)
-        continue;
-      const filePath = op.vcs.filePath;
-      if (!hashHistory.has(filePath)) {
-        hashHistory.set(filePath, []);
-      }
-      const history = hashHistory.get(filePath);
-      const currentHash = op.vcs.contentHash;
-      const priorIdx = history.findIndex((h) => h.hash === currentHash);
-      if (priorIdx >= 0 && priorIdx < history.length - 1) {
-        const revertedStartIdx = history[priorIdx + 1].opIdx;
-        const revertedEndIdx = history[history.length - 1].opIdx;
-        const revertedOps = ops.slice(revertedStartIdx, revertedEndIdx + 1).filter((o) => isFileOp(o) && o.vcs?.filePath === filePath && !milestonedOpHashes.has(o.hash));
-        if (revertedOps.length >= 2) {
-          clusters.push({
-            id: generateClusterId("rev", revertedOps),
-            ops: revertedOps,
-            firstOp: revertedOps[0].hash,
-            lastOp: revertedOps[revertedOps.length - 1].hash,
-            affectedFiles: [filePath],
-            affectedSymbols: [],
-            estimatedIntent: "",
-            createdAt: revertedOps[0].timestamp,
-            abandonedAt: op.timestamp,
-            status: "abandoned",
-            detectedBy: "revert"
-          });
+  results.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
+  return results;
+}
+var FILE_OP_KINDS, contextSwitchDetector, revertDetector, staleBranchDetector, defaultDetectors;
+var init_cluster = __esm(() => {
+  FILE_OP_KINDS = new Set([
+    "vcs:fileAdd",
+    "vcs:fileModify",
+    "vcs:fileDelete",
+    "vcs:fileRename"
+  ]);
+  contextSwitchDetector = {
+    name: "context-switch",
+    detect(ops, milestonedOpHashes) {
+      const fileOps = ops.filter((o) => isFileOp(o) && !milestonedOpHashes.has(o.hash));
+      if (fileOps.length < 2)
+        return [];
+      const groups = [];
+      let currentGroup = [];
+      let currentFiles = new Set;
+      for (const op of fileOps) {
+        const opFile = op.vcs?.filePath;
+        if (!opFile)
+          continue;
+        const opDir = opFile.split("/").slice(0, -1).join("/") || ".";
+        if (currentGroup.length === 0) {
+          currentGroup.push(op);
+          currentFiles.add(opDir);
+          continue;
         }
-      }
-      history.push({ hash: currentHash, opIdx: i });
-    }
-    return clusters;
-  }
-};
-var staleBranchDetector = {
-  name: "stale-branch",
-  detect(ops, milestonedOpHashes) {
-    const clusters = [];
-    const branchOps = new Map;
-    let currentBranch = "main";
-    for (const op of ops) {
-      if (op.kind === "vcs:branchCreate" && op.vcs?.branchName) {
-        currentBranch = op.vcs.branchName;
-        if (!branchOps.has(currentBranch)) {
-          branchOps.set(currentBranch, []);
+        const currentDirs = [...currentFiles];
+        const hasOverlap = currentDirs.some((d) => opDir.startsWith(d) || d.startsWith(opDir) || d === opDir);
+        if (hasOverlap) {
+          currentGroup.push(op);
+          currentFiles.add(opDir);
+        } else {
+          if (currentGroup.length > 0) {
+            groups.push(currentGroup);
+          }
+          currentGroup = [op];
+          currentFiles = new Set([opDir]);
         }
       }
-      if (isFileOp(op) && !milestonedOpHashes.has(op.hash)) {
-        if (!branchOps.has(currentBranch)) {
-          branchOps.set(currentBranch, []);
-        }
-        branchOps.get(currentBranch).push(op);
+      if (currentGroup.length > 0) {
+        groups.push(currentGroup);
       }
-    }
-    for (const [branchName, fileOps] of branchOps) {
-      if (branchName === "main")
-        continue;
-      if (fileOps.length < 2)
-        continue;
-      const lastOpTime = new Date(fileOps[fileOps.length - 1].timestamp).getTime();
-      const now = Date.now();
-      const daysSinceLastOp = (now - lastOpTime) / (1000 * 60 * 60 * 24);
-      if (daysSinceLastOp > 7) {
+      const clusters = [];
+      for (let i = 0;i < groups.length - 1; i++) {
+        const group = groups[i];
+        if (group.length < 2)
+          continue;
         clusters.push({
-          id: generateClusterId("stale", fileOps),
-          ops: fileOps,
-          firstOp: fileOps[0].hash,
-          lastOp: fileOps[fileOps.length - 1].hash,
-          affectedFiles: extractFiles(fileOps),
+          id: generateClusterId("ctx", group),
+          ops: group,
+          firstOp: group[0].hash,
+          lastOp: group[group.length - 1].hash,
+          affectedFiles: extractFiles(group),
           affectedSymbols: [],
           estimatedIntent: "",
-          createdAt: fileOps[0].timestamp,
-          abandonedAt: fileOps[fileOps.length - 1].timestamp,
+          createdAt: group[0].timestamp,
+          abandonedAt: group[group.length - 1].timestamp,
           status: "abandoned",
-          detectedBy: "stale-branch"
+          detectedBy: "context-switch"
         });
       }
+      return clusters;
     }
-    return clusters;
-  }
-};
-var defaultDetectors = [
-  contextSwitchDetector,
-  revertDetector,
-  staleBranchDetector
-];
-function detectClusters(ops, milestonedOpHashes, detectors = defaultDetectors) {
-  const seen = new Set;
-  const results = [];
-  for (const detector of detectors) {
-    const clusters = detector.detect(ops, milestonedOpHashes);
-    for (const cluster of clusters) {
-      if (!seen.has(cluster.id)) {
-        seen.add(cluster.id);
-        results.push(cluster);
+  };
+  revertDetector = {
+    name: "revert",
+    detect(ops, milestonedOpHashes) {
+      const clusters = [];
+      const hashHistory = new Map;
+      for (let i = 0;i < ops.length; i++) {
+        const op = ops[i];
+        if (!isFileOp(op) || !op.vcs?.filePath || !op.vcs?.contentHash)
+          continue;
+        const filePath = op.vcs.filePath;
+        if (!hashHistory.has(filePath)) {
+          hashHistory.set(filePath, []);
+        }
+        const history = hashHistory.get(filePath);
+        const currentHash = op.vcs.contentHash;
+        const priorIdx = history.findIndex((h) => h.hash === currentHash);
+        if (priorIdx >= 0 && priorIdx < history.length - 1) {
+          const revertedStartIdx = history[priorIdx + 1].opIdx;
+          const revertedEndIdx = history[history.length - 1].opIdx;
+          const revertedOps = ops.slice(revertedStartIdx, revertedEndIdx + 1).filter((o) => isFileOp(o) && o.vcs?.filePath === filePath && !milestonedOpHashes.has(o.hash));
+          if (revertedOps.length >= 2) {
+            clusters.push({
+              id: generateClusterId("rev", revertedOps),
+              ops: revertedOps,
+              firstOp: revertedOps[0].hash,
+              lastOp: revertedOps[revertedOps.length - 1].hash,
+              affectedFiles: [filePath],
+              affectedSymbols: [],
+              estimatedIntent: "",
+              createdAt: revertedOps[0].timestamp,
+              abandonedAt: op.timestamp,
+              status: "abandoned",
+              detectedBy: "revert"
+            });
+          }
+        }
+        history.push({ hash: currentHash, opIdx: i });
       }
+      return clusters;
     }
-  }
-  results.sort((a, b) => new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime());
-  return results;
-}
+  };
+  staleBranchDetector = {
+    name: "stale-branch",
+    detect(ops, milestonedOpHashes) {
+      const clusters = [];
+      const branchOps = new Map;
+      let currentBranch = "main";
+      for (const op of ops) {
+        if (op.kind === "vcs:branchCreate" && op.vcs?.branchName) {
+          currentBranch = op.vcs.branchName;
+          if (!branchOps.has(currentBranch)) {
+            branchOps.set(currentBranch, []);
+          }
+        }
+        if (isFileOp(op) && !milestonedOpHashes.has(op.hash)) {
+          if (!branchOps.has(currentBranch)) {
+            branchOps.set(currentBranch, []);
+          }
+          branchOps.get(currentBranch).push(op);
+        }
+      }
+      for (const [branchName, fileOps] of branchOps) {
+        if (branchName === "main")
+          continue;
+        if (fileOps.length < 2)
+          continue;
+        const lastOpTime = new Date(fileOps[fileOps.length - 1].timestamp).getTime();
+        const now = Date.now();
+        const daysSinceLastOp = (now - lastOpTime) / (1000 * 60 * 60 * 24);
+        if (daysSinceLastOp > 7) {
+          clusters.push({
+            id: generateClusterId("stale", fileOps),
+            ops: fileOps,
+            firstOp: fileOps[0].hash,
+            lastOp: fileOps[fileOps.length - 1].hash,
+            affectedFiles: extractFiles(fileOps),
+            affectedSymbols: [],
+            estimatedIntent: "",
+            createdAt: fileOps[0].timestamp,
+            abandonedAt: fileOps[fileOps.length - 1].timestamp,
+            status: "abandoned",
+            detectedBy: "stale-branch"
+          });
+        }
+      }
+      return clusters;
+    }
+  };
+  defaultDetectors = [
+    contextSwitchDetector,
+    revertDetector,
+    staleBranchDetector
+  ];
+});
+
 // src/garden/garden.ts
 class IdeaGarden {
   ctx;
@@ -653,25 +693,17 @@ function buildMilestonedOpHashes(ops) {
   }
   return milestoned;
 }
+var init_garden = __esm(() => {
+  init_cluster();
+});
+
+// src/garden/index.ts
+var init_garden2 = __esm(() => {
+  init_cluster();
+  init_garden();
+});
+
 // src/semantic/ts-parser.ts
-var typescriptParser = {
-  languages: ["typescript", "javascript", "tsx", "jsx"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    const language = detectLanguage2(filePath);
-    return {
-      fileEntityId,
-      filePath,
-      language,
-      declarations: extractDeclarations(content, filePath),
-      imports: extractImports(content),
-      exports: extractExports(content)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff(oldResult, newResult);
-  }
-};
 function detectLanguage2(filePath) {
   if (filePath.endsWith(".tsx"))
     return "tsx";
@@ -1121,24 +1153,29 @@ function makeEntityId(filePath, kind, name) {
 function normalizeSignature(text) {
   return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").replace(/;\s*$/, "").trim();
 }
+var typescriptParser;
+var init_ts_parser = __esm(() => {
+  typescriptParser = {
+    languages: ["typescript", "javascript", "tsx", "jsx"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      const language = detectLanguage2(filePath);
+      return {
+        fileEntityId,
+        filePath,
+        language,
+        declarations: extractDeclarations(content, filePath),
+        imports: extractImports(content),
+        exports: extractExports(content)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff(oldResult, newResult);
+    }
+  };
+});
+
 // src/semantic/python-parser.ts
-var pythonParser = {
-  languages: ["python"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    return {
-      fileEntityId,
-      filePath,
-      language: "python",
-      declarations: extractDeclarations2(content, filePath),
-      imports: extractImports2(content),
-      exports: extractExports2(content)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff2(oldResult, newResult);
-  }
-};
 function extractDeclarations2(content, filePath) {
   const declarations = [];
   const lines = content.split(`
@@ -1512,24 +1549,28 @@ function makeEntityId2(filePath, kind, name) {
 function normalizeSignature2(text) {
   return text.replace(/#[^\n]*/g, "").replace(/"""[\s\S]*?"""/g, "").replace(/'''[\s\S]*?'''/g, "").replace(/\s+/g, " ").trim();
 }
+var pythonParser;
+var init_python_parser = __esm(() => {
+  pythonParser = {
+    languages: ["python"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      return {
+        fileEntityId,
+        filePath,
+        language: "python",
+        declarations: extractDeclarations2(content, filePath),
+        imports: extractImports2(content),
+        exports: extractExports2(content)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff2(oldResult, newResult);
+    }
+  };
+});
+
 // src/semantic/go-parser.ts
-var goParser = {
-  languages: ["go"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    return {
-      fileEntityId,
-      filePath,
-      language: "go",
-      declarations: extractDeclarations3(content, filePath),
-      imports: extractImports3(content),
-      exports: extractExports3(content, filePath)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff3(oldResult, newResult);
-  }
-};
 function extractDeclarations3(content, filePath) {
   const declarations = [];
   const lines = content.split(`
@@ -1940,24 +1981,28 @@ function makeEntityId3(filePath, kind, name) {
 function normalizeSignature3(text) {
   return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
 }
+var goParser;
+var init_go_parser = __esm(() => {
+  goParser = {
+    languages: ["go"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      return {
+        fileEntityId,
+        filePath,
+        language: "go",
+        declarations: extractDeclarations3(content, filePath),
+        imports: extractImports3(content),
+        exports: extractExports3(content, filePath)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff3(oldResult, newResult);
+    }
+  };
+});
+
 // src/semantic/rust-parser.ts
-var rustParser = {
-  languages: ["rust"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    return {
-      fileEntityId,
-      filePath,
-      language: "rust",
-      declarations: extractDeclarations4(content, filePath),
-      imports: extractImports4(content),
-      exports: extractExports4(content, filePath)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff4(oldResult, newResult);
-  }
-};
 function extractDeclarations4(content, filePath) {
   const declarations = [];
   const lines = content.split(`
@@ -2392,24 +2437,28 @@ function makeEntityId4(filePath, kind, name) {
 function normalizeSignature4(text) {
   return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
 }
+var rustParser;
+var init_rust_parser = __esm(() => {
+  rustParser = {
+    languages: ["rust"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      return {
+        fileEntityId,
+        filePath,
+        language: "rust",
+        declarations: extractDeclarations4(content, filePath),
+        imports: extractImports4(content),
+        exports: extractExports4(content, filePath)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff4(oldResult, newResult);
+    }
+  };
+});
+
 // src/semantic/ruby-parser.ts
-var rubyParser = {
-  languages: ["ruby"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    return {
-      fileEntityId,
-      filePath,
-      language: "ruby",
-      declarations: extractDeclarations5(content, filePath),
-      imports: extractImports5(content),
-      exports: extractExports5(content)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff5(oldResult, newResult);
-  }
-};
 function extractDeclarations5(content, filePath) {
   const declarations = [];
   const lines = content.split(`
@@ -2718,28 +2767,28 @@ function makeEntityId5(filePath, kind, name) {
 function normalizeSignature5(text) {
   return text.replace(/#[^\n]*/g, "").replace(/\s+/g, " ").trim();
 }
+var rubyParser;
+var init_ruby_parser = __esm(() => {
+  rubyParser = {
+    languages: ["ruby"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      return {
+        fileEntityId,
+        filePath,
+        language: "ruby",
+        declarations: extractDeclarations5(content, filePath),
+        imports: extractImports5(content),
+        exports: extractExports5(content)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff5(oldResult, newResult);
+    }
+  };
+});
+
 // src/semantic/java-parser.ts
-var javaParser = {
-  languages: ["java"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    return {
-      fileEntityId,
-      filePath,
-      language: "java",
-      declarations: extractDeclarations6(content, filePath),
-      imports: extractImports6(content),
-      exports: extractExports6(content, filePath)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff6(oldResult, newResult);
-  }
-};
-var MODIFIERS = /(?:(?:public|private|protected|static|final|abstract|synchronized|native|transient|volatile|strictfp|sealed|non-sealed|default)\s+)*/;
-var CLASS_RE = new RegExp(`^${MODIFIERS.source}(class|interface|enum|record|@interface)\\s+(\\w+)`);
-var METHOD_RE = new RegExp(`^${MODIFIERS.source}(?:<[^>]+>\\s+)?(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*\\(`);
-var FIELD_RE = new RegExp(`^${MODIFIERS.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[;=]`);
 function extractDeclarations6(content, filePath) {
   const declarations = [];
   const lines = content.split(`
@@ -3047,29 +3096,32 @@ function makeEntityId6(filePath, kind, name) {
 function normalizeSignature6(text) {
   return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
 }
+var javaParser, MODIFIERS, CLASS_RE, METHOD_RE, FIELD_RE;
+var init_java_parser = __esm(() => {
+  javaParser = {
+    languages: ["java"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      return {
+        fileEntityId,
+        filePath,
+        language: "java",
+        declarations: extractDeclarations6(content, filePath),
+        imports: extractImports6(content),
+        exports: extractExports6(content, filePath)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff6(oldResult, newResult);
+    }
+  };
+  MODIFIERS = /(?:(?:public|private|protected|static|final|abstract|synchronized|native|transient|volatile|strictfp|sealed|non-sealed|default)\s+)*/;
+  CLASS_RE = new RegExp(`^${MODIFIERS.source}(class|interface|enum|record|@interface)\\s+(\\w+)`);
+  METHOD_RE = new RegExp(`^${MODIFIERS.source}(?:<[^>]+>\\s+)?(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*\\(`);
+  FIELD_RE = new RegExp(`^${MODIFIERS.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[;=]`);
+});
+
 // src/semantic/csharp-parser.ts
-var csharpParser = {
-  languages: ["csharp"],
-  parse(content, filePath) {
-    const fileEntityId = `file:${filePath}`;
-    return {
-      fileEntityId,
-      filePath,
-      language: "csharp",
-      declarations: extractDeclarations7(content, filePath),
-      imports: extractImports7(content),
-      exports: extractExports7(content)
-    };
-  },
-  diff(oldResult, newResult) {
-    return computeSemanticDiff7(oldResult, newResult);
-  }
-};
-var MODIFIERS_RE = /(?:(?:public|private|protected|internal|static|abstract|sealed|virtual|override|partial|readonly|async|extern|unsafe|volatile|new)\s+)*/;
-var TYPE_DEF_RE = new RegExp(`^${MODIFIERS_RE.source}(class|interface|struct|enum|record)\\s+(\\w+)`);
-var METHOD_RE2 = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[(<]`);
-var PROP_RE = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*\\{`);
-var FIELD_RE2 = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[;=]`);
 function extractDeclarations7(content, filePath) {
   const declarations = [];
   const lines = content.split(`
@@ -3149,7 +3201,6 @@ function extractBraceBlock4(name, kind, lines, startLine, defLine, filePath) {
     endLine
   };
 }
-var CONTROL_FLOW = new Set(["if", "for", "foreach", "while", "switch", "catch", "using", "lock", "try", "else", "return", "throw", "new", "yield", "await"]);
 function extractTypeMembers(lines, startLine, endLine, parentName, filePath) {
   const children = [];
   let depth = 0;
@@ -3403,7 +3454,59 @@ function makeEntityId7(filePath, kind, name) {
 function normalizeSignature7(text) {
   return text.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "").replace(/\s+/g, " ").trim();
 }
+var csharpParser, MODIFIERS_RE, TYPE_DEF_RE, METHOD_RE2, PROP_RE, FIELD_RE2, CONTROL_FLOW;
+var init_csharp_parser = __esm(() => {
+  csharpParser = {
+    languages: ["csharp"],
+    parse(content, filePath) {
+      const fileEntityId = `file:${filePath}`;
+      return {
+        fileEntityId,
+        filePath,
+        language: "csharp",
+        declarations: extractDeclarations7(content, filePath),
+        imports: extractImports7(content),
+        exports: extractExports7(content)
+      };
+    },
+    diff(oldResult, newResult) {
+      return computeSemanticDiff7(oldResult, newResult);
+    }
+  };
+  MODIFIERS_RE = /(?:(?:public|private|protected|internal|static|abstract|sealed|virtual|override|partial|readonly|async|extern|unsafe|volatile|new)\s+)*/;
+  TYPE_DEF_RE = new RegExp(`^${MODIFIERS_RE.source}(class|interface|struct|enum|record)\\s+(\\w+)`);
+  METHOD_RE2 = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[(<]`);
+  PROP_RE = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*\\{`);
+  FIELD_RE2 = new RegExp(`^${MODIFIERS_RE.source}(?:\\w[\\w<>\\[\\],\\s?]*?)\\s+(\\w+)\\s*[;=]`);
+  CONTROL_FLOW = new Set(["if", "for", "foreach", "while", "switch", "catch", "using", "lock", "try", "else", "return", "throw", "new", "yield", "await"]);
+});
+
+// src/semantic/semantic-merge.ts
+var init_semantic_merge = () => {};
+
+// src/semantic/index.ts
+var init_semantic = __esm(() => {
+  init_ts_parser();
+  init_python_parser();
+  init_go_parser();
+  init_rust_parser();
+  init_ruby_parser();
+  init_java_parser();
+  init_csharp_parser();
+  init_semantic_merge();
+});
+
 // src/engine.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  copyFileSync
+} from "fs";
+import { readFile as readFile2 } from "fs/promises";
+import { join as join2, dirname } from "path";
+
 class JsonOpLog {
   ops = [];
   filePath;
@@ -3545,7 +3648,7 @@ class TrellisVcsEngine {
     this.store = new EAVStore;
     this.opLog = new JsonOpLog(join2(this.config.rootPath, ".trellis", "ops.json"));
   }
-  async initRepo() {
+  async initRepo(opts) {
     const trellisDir = join2(this.config.rootPath, ".trellis");
     if (!existsSync(trellisDir)) {
       mkdirSync(trellisDir, { recursive: true });
@@ -3576,8 +3679,26 @@ class TrellisVcsEngine {
       debounceMs: this.config.debounceMs,
       onEvent: () => {}
     });
-    const events = await scanner.scan();
+    const events = await scanner.scan({
+      onProgress: (progress) => {
+        if (progress.phase === "done") {
+          return;
+        }
+        opts?.onProgress?.({
+          phase: progress.phase,
+          current: progress.current,
+          total: progress.total,
+          message: progress.message
+        });
+      }
+    });
     let opsCreated = 1;
+    opts?.onProgress?.({
+      phase: "recording",
+      current: 0,
+      total: events.length,
+      message: `Recording ${events.length} initial file operations\u2026`
+    });
     for (const event of events) {
       if (event.contentHash) {
         try {
@@ -3597,8 +3718,23 @@ class TrellisVcsEngine {
       });
       this.applyOp(op);
       opsCreated++;
+      const recordedFiles = opsCreated - 1;
+      if (recordedFiles % 25 === 0 || recordedFiles === events.length) {
+        opts?.onProgress?.({
+          phase: "recording",
+          current: recordedFiles,
+          total: events.length,
+          message: `Recorded ${recordedFiles}/${events.length} initial file ops`
+        });
+      }
     }
     await this.flushAutoCheckpoint();
+    opts?.onProgress?.({
+      phase: "done",
+      current: opsCreated,
+      total: opsCreated,
+      message: `Initialized repository with ${opsCreated} operations`
+    });
     return { opsCreated };
   }
   open() {
@@ -4034,5 +4170,23 @@ class TrellisVcsEngine {
     }
   }
 }
+var init_engine = __esm(() => {
+  init_eav_store();
+  init_fs_watcher();
+  init_ingestion();
+  init_decompose();
+  init_ops();
+  init_types();
+  init_blob_store();
+  init_branch();
+  init_milestone();
+  init_checkpoint();
+  init_diff();
+  init_merge();
+  init_issue();
+  init_decisions();
+  init_garden2();
+  init_semantic();
+});
 
-export { FileWatcher, Ingestion, TrellisVcsEngine };
+export { FileWatcher, init_fs_watcher, Ingestion, init_ingestion, TrellisVcsEngine, init_engine };