@ulpi/cli 0.1.1 → 0.1.2

package/dist/{chunk-6JCMYYBT.js → chunk-FNPD3V2X.js}

@@ -1,6 +1,13 @@
 import {
   createEmbedder
-} from "./chunk-DBMUNBNB.js";
+} from "./chunk-VGZLMUNO.js";
+import {
+  commitInWorktree,
+  copyAndStage,
+  historyBranchExists,
+  withWorktree,
+  writeAndStage
+} from "./chunk-NNUWU6CV.js";
 import {
   readEvents
 } from "./chunk-YM2HV4IA.js";
@@ -248,9 +255,7 @@ function finalizeCapture(sessionId, state, projectDir) {
   const dir = sessionCaptureDir(projectDir, sessionId);
   fs3.mkdirSync(dir, { recursive: true });
   const redactPatterns = config.redactPatterns;
-  if (config.captureMode === "end_of_session") {
-    bulkCaptureFromSessionLog(sessionId, projectDir, redactPatterns);
-  }
+  bulkCaptureFromSessionLog(sessionId, projectDir, redactPatterns);
   let transcriptCaptured = false;
   if (state.transcriptPath) {
     transcriptCaptured = copyTranscript(
@@ -550,6 +555,8 @@ function invokeClassifier(prompt, model, timeout) {
     throw new Error("Claude CLI not found \u2014 cannot classify memories");
   }
   return new Promise((resolve2, reject) => {
+    const env = { ...process.env };
+    delete env.CLAUDECODE;
     const proc = spawn(claudePath, [
       "--print",
       "--model",
@@ -561,7 +568,8 @@ function invokeClassifier(prompt, model, timeout) {
       "--permission-mode",
       "bypassPermissions"
     ], {
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      env
     });
     let stdout = "";
     let stderr = "";
@@ -1324,17 +1332,7 @@ async function rememberMemory(projectDir, entry) {
   }
 }
 function memoryBranchExists(projectDir) {
-  const branch = getMemoryBranch();
-  try {
-    execFileSync2("git", ["rev-parse", "--verify", `refs/heads/${branch}`], {
-      cwd: projectDir,
-      stdio: "pipe",
-      timeout: 5e3
-    });
-    return true;
-  } catch {
-    return false;
-  }
+  return historyBranchExists(projectDir, getMemoryBranch());
 }
 function initMemoryBranch(projectDir) {
   const branch = getMemoryBranch();
@@ -1385,114 +1383,200 @@ function initMemoryBranch(projectDir) {
     }
   }
 }
-function exportMemories(projectDir) {
-  const branch = getMemoryBranch();
+async function exportMemories(projectDir) {
+  const branchName = getMemoryBranch();
   if (!memoryBranchExists(projectDir)) {
     initMemoryBranch(projectDir);
   }
   const entries = listEntries(projectDir);
   const config = loadMemoryConfig(projectDir);
-  const exportData = {
-    version: 1,
-    exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-    projectDir,
-    memories: entries,
-    config
-  };
-  const tmpDir = fs9.mkdtempSync(path9.join(os3.tmpdir(), "ulpi-memory-export-"));
-  try {
-    execFileSync2("git", ["worktree", "add", tmpDir, branch], {
-      cwd: projectDir,
-      stdio: "pipe",
-      timeout: 1e4
-    });
-    fs9.writeFileSync(
-      path9.join(tmpDir, "memories.json"),
-      JSON.stringify(exportData, null, 2) + "\n"
-    );
-    execFileSync2("git", ["add", "memories.json"], {
-      cwd: tmpDir,
-      stdio: "pipe",
-      timeout: 5e3
-    });
-    try {
-      execFileSync2("git", ["diff", "--cached", "--quiet"], {
-        cwd: tmpDir,
-        stdio: "pipe",
-        timeout: 5e3
-      });
-      const sha2 = execFileSync2("git", ["rev-parse", "HEAD"], {
-        cwd: tmpDir,
-        encoding: "utf-8",
-        timeout: 5e3
-      }).trim();
-      return { branchName: branch, commitSha: sha2, memoriesExported: entries.length };
-    } catch {
+  const lanceDir = memoryLanceDir(projectDir);
+  const statsFile = memoryStatsFile(projectDir);
+  let filesExported = 0;
+  let totalSizeBytes = 0;
+  const commitSha = await withWorktree(projectDir, branchName, (worktreeDir) => {
+    const exportData = {
+      version: 1,
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      projectDir,
+      memories: entries,
+      config
+    };
+    const memoriesJson = JSON.stringify(exportData, null, 2) + "\n";
+    writeAndStage(worktreeDir, "memories.json", memoriesJson);
+    totalSizeBytes += Buffer.byteLength(memoriesJson, "utf-8");
+    filesExported++;
+    const configPath = memoryConfigFile(projectDir);
+    if (fs9.existsSync(configPath)) {
+      const content = fs9.readFileSync(configPath, "utf-8");
+      writeAndStage(worktreeDir, "config.json", content);
+      totalSizeBytes += Buffer.byteLength(content, "utf-8");
+      filesExported++;
     }
-    execFileSync2("git", [
-      "commit",
-      "-m",
-      `memory: export ${entries.length} memories`
-    ], {
-      cwd: tmpDir,
-      stdio: "pipe",
-      timeout: 1e4
-    });
-    const sha = execFileSync2("git", ["rev-parse", "HEAD"], {
-      cwd: tmpDir,
-      encoding: "utf-8",
-      timeout: 5e3
-    }).trim();
-    return { branchName: branch, commitSha: sha, memoriesExported: entries.length };
-  } finally {
-    try {
-      execFileSync2("git", ["worktree", "remove", "--force", tmpDir], {
-        cwd: projectDir,
-        stdio: "pipe",
-        timeout: 1e4
-      });
-    } catch {
-      try {
-        fs9.rmSync(tmpDir, { recursive: true, force: true });
-      } catch {
-      }
+    if (fs9.existsSync(statsFile)) {
+      const content = fs9.readFileSync(statsFile, "utf-8");
+      writeAndStage(worktreeDir, "stats.json", content);
+      totalSizeBytes += Buffer.byteLength(content, "utf-8");
+      filesExported++;
+    }
+    if (fs9.existsSync(lanceDir)) {
+      const result = copyDirRecursive(lanceDir, worktreeDir, "index/lance");
+      filesExported += result.fileCount;
+      totalSizeBytes += result.totalBytes;
+    }
+    const exportMeta = {
+      exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      indexVersion: 1,
+      vectorStoreFormatVersion: 1,
+      engine: "lancedb"
+    };
+    writeAndStage(worktreeDir, "export-meta.json", JSON.stringify(exportMeta, null, 2) + "\n");
+    filesExported++;
+    const readme = [
+      "# ULPI Agent Memory",
+      "",
+      "This branch stores agent memory data for this repository.",
+      "It is maintained automatically by [ULPI](https://github.com/ulpi-io/ulpi).",
+      "",
+      "## Contents",
+      "",
+      "- `memories.json` \u2014 Memory entries + config snapshot",
+      "- `config.json` \u2014 Memory configuration",
+      "- `stats.json` \u2014 Memory statistics",
+      "- `index/lance/` \u2014 LanceDB vector index",
+      "- `export-meta.json` \u2014 Export metadata",
+      "",
+      `_Exported: ${exportMeta.exportedAt} \u2014 ${entries.length} memories_`
+    ].join("\n") + "\n";
+    writeAndStage(worktreeDir, "README.md", readme);
+    filesExported++;
+    return commitInWorktree(worktreeDir, `memory: export ${entries.length} memories (${filesExported} files)`);
+  });
+  const commitMessage = `memory: export ${entries.length} memories (${filesExported} files)`;
+  const tree = execFileSync2("git", ["rev-parse", `${commitSha}^{tree}`], {
+    cwd: projectDir,
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  const orphanSha = execFileSync2("git", ["commit-tree", tree, "-m", commitMessage], {
+    cwd: projectDir,
+    encoding: "utf-8",
+    timeout: 5e3
+  }).trim();
+  execFileSync2("git", ["update-ref", `refs/heads/${branchName}`, orphanSha], {
+    cwd: projectDir,
+    timeout: 5e3
+  });
+  return {
+    branchName,
+    commitSha: orphanSha,
+    memoriesExported: entries.length,
+    filesExported,
+    totalSizeBytes
+  };
+}
+function copyDirRecursive(srcDir, worktreeDir, prefix) {
+  let fileCount = 0;
+  let totalBytes = 0;
+  const dirEntries = fs9.readdirSync(srcDir);
+  for (const entry of dirEntries) {
+    const srcPath = path9.join(srcDir, entry);
+    const destRelative = `${prefix}/${entry}`;
+    const stat = fs9.statSync(srcPath);
+    if (stat.isDirectory()) {
+      const sub = copyDirRecursive(srcPath, worktreeDir, destRelative);
+      fileCount += sub.fileCount;
+      totalBytes += sub.totalBytes;
+    } else if (stat.isFile()) {
+      copyAndStage(worktreeDir, destRelative, srcPath);
+      totalBytes += stat.size;
+      fileCount++;
     }
   }
+  return { fileCount, totalBytes };
 }
-function importMemories(projectDir) {
-  const branch = getMemoryBranch();
+async function importMemories(projectDir) {
+  const branchName = getMemoryBranch();
   if (!memoryBranchExists(projectDir)) {
-    return { success: false, memoriesImported: 0, message: "Memory branch does not exist" };
+    return { success: false, memoriesImported: 0, filesImported: 0, totalSizeBytes: 0, message: "Memory branch does not exist" };
   }
-  try {
-    const raw = execFileSync2(
-      "git",
-      ["show", `${branch}:memories.json`],
-      { cwd: projectDir, encoding: "utf-8", timeout: 1e4 }
-    );
-    const exportData = JSON.parse(raw);
-    if (!exportData.memories || !Array.isArray(exportData.memories)) {
-      return { success: false, memoriesImported: 0, message: "Invalid export data" };
-    }
-    const entriesDir = memoryEntriesDir(projectDir);
-    fs9.mkdirSync(entriesDir, { recursive: true });
-    let imported = 0;
-    for (const entry of exportData.memories) {
-      const filePath = path9.join(entriesDir, `${entry.id}.json`);
-      if (!fs9.existsSync(filePath)) {
-        fs9.writeFileSync(filePath, JSON.stringify(entry, null, 2) + "\n", "utf-8");
-        imported++;
+  const memDir = projectMemoryDir(projectDir);
+  let memoriesImported = 0;
+  let filesImported = 0;
+  let totalSizeBytes = 0;
+  await withWorktree(projectDir, branchName, (worktreeDir) => {
+    const memoriesPath = path9.join(worktreeDir, "memories.json");
+    if (fs9.existsSync(memoriesPath)) {
+      const raw = fs9.readFileSync(memoriesPath, "utf-8");
+      const exportData = JSON.parse(raw);
+      totalSizeBytes += Buffer.byteLength(raw, "utf-8");
+      filesImported++;
+      if (exportData.memories && Array.isArray(exportData.memories)) {
+        const entriesDir = memoryEntriesDir(projectDir);
+        fs9.mkdirSync(entriesDir, { recursive: true });
+        for (const entry of exportData.memories) {
+          const filePath = path9.join(entriesDir, `${entry.id}.json`);
+          if (!fs9.existsSync(filePath)) {
+            fs9.writeFileSync(filePath, JSON.stringify(entry, null, 2) + "\n", "utf-8");
+            memoriesImported++;
+          }
+        }
       }
     }
-    return {
-      success: true,
-      memoriesImported: imported,
-      message: `Imported ${imported} new memories (${exportData.memories.length - imported} already exist)`
-    };
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    return { success: false, memoriesImported: 0, message };
+    const configSrc = path9.join(worktreeDir, "config.json");
+    const configDest = memoryConfigFile(projectDir);
+    if (fs9.existsSync(configSrc) && !fs9.existsSync(configDest)) {
+      fs9.mkdirSync(path9.dirname(configDest), { recursive: true });
+      const content = fs9.readFileSync(configSrc);
+      fs9.writeFileSync(configDest, content);
+      totalSizeBytes += content.length;
+      filesImported++;
+    }
+    const statsSrc = path9.join(worktreeDir, "stats.json");
+    const statsDest = memoryStatsFile(projectDir);
+    if (fs9.existsSync(statsSrc) && !fs9.existsSync(statsDest)) {
+      const content = fs9.readFileSync(statsSrc);
+      fs9.writeFileSync(statsDest, content);
+      totalSizeBytes += content.length;
+      filesImported++;
+    }
+    const lanceSrc = path9.join(worktreeDir, "index", "lance");
+    const lanceDest = memoryLanceDir(projectDir);
+    if (fs9.existsSync(lanceSrc)) {
+      fs9.mkdirSync(lanceDest, { recursive: true });
+      const result = copyDirRecursiveImport(lanceSrc, lanceDest);
+      filesImported += result.fileCount;
+      totalSizeBytes += result.totalBytes;
+    }
+  });
+  return {
+    success: true,
+    memoriesImported,
+    filesImported,
+    totalSizeBytes,
+    message: memoriesImported > 0 ? `Imported ${memoriesImported} new memories + vector index (${filesImported} files)` : `Vector index restored (${filesImported} files, entries already exist)`
+  };
+}
+function copyDirRecursiveImport(srcDir, destDir) {
+  let fileCount = 0;
+  let totalBytes = 0;
+  fs9.mkdirSync(destDir, { recursive: true });
+  const dirEntries = fs9.readdirSync(srcDir);
+  for (const entry of dirEntries) {
+    const srcPath = path9.join(srcDir, entry);
+    const destPath = path9.join(destDir, entry);
+    const stat = fs9.statSync(srcPath);
+    if (stat.isDirectory()) {
+      const sub = copyDirRecursiveImport(srcPath, destPath);
+      fileCount += sub.fileCount;
+      totalBytes += sub.totalBytes;
+    } else if (stat.isFile()) {
+      fs9.copyFileSync(srcPath, destPath);
+      totalBytes += stat.size;
+      fileCount++;
+    }
   }
+  return { fileCount, totalBytes };
 }
 
 export {

package/dist/{chunk-4KRVDKGB.js → chunk-S253WCQJ.js}

@@ -13,7 +13,7 @@ var REGISTRY_URL = CLI_REGISTRY_URL;
 var FETCH_TIMEOUT_MS = 5e3;
 function getCurrentVersion() {
   try {
-    return "0.1.1";
+    return "0.1.2";
   } catch {
     return "0.0.0";
   }

package/dist/{chunk-Q4HIY43N.js → chunk-UA6EFK64.js}

@@ -74,7 +74,7 @@ import {
   saveUlpiSettings
 } from "./chunk-7LXY5UVC.js";
 
-// ../api/dist/chunk-3N5EEDFM.js
+// ../api/dist/chunk-77FAT4LI.js
 import * as http from "http";
 import * as fs12 from "fs";
 import * as path9 from "path";
@@ -2245,7 +2245,7 @@ async function exportObsidian(ctx) {
   jsonResponse(ctx.res, { format: "obsidian", content: md }, 200, ctx.req);
 }
 async function getEngine() {
-  return await import("./dist-LZKZFPVX.js");
+  return await import("./dist-MFFX7TZW.js");
 }
 var runningPipelines = /* @__PURE__ */ new Map();
 var activeWatchers = /* @__PURE__ */ new Map();
@@ -2551,7 +2551,7 @@ async function codemapActionHandler(ctx) {
   }
 }
 async function getEngine2() {
-  return await import("./dist-R5F4MX3I.js");
+  return await import("./dist-57UMTPGR.js");
 }
 async function memoryStatusHandler(ctx) {
   try {
@@ -2765,12 +2765,12 @@ async function memoryActionHandler(ctx) {
         return;
       }
       case "export": {
-        const result = engine.exportMemories(ctx.projectDir);
+        const result = await engine.exportMemories(ctx.projectDir);
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
         return;
       }
       case "import": {
-        const result = engine.importMemories(ctx.projectDir);
+        const result = await engine.importMemories(ctx.projectDir);
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
         return;
       }
@@ -2855,7 +2855,7 @@ async function memoryConfigUpdateHandler(ctx) {
   }
 }
 async function getDepgraph() {
-  return await import("./dist-R5ZJ4LX5.js");
+  return await import("./dist-YA2BWZB2.js");
 }
 async function getBranch(projectDir) {
   const { getCurrentBranch: getCurrentBranch2 } = await import("./dist-RKOGLK7R.js");
@@ -3014,11 +3014,7 @@ async function depgraphMetricsHandler(ctx) {
     jsonResponse(ctx.res, { error: error ?? "Invalid request body" }, 400, ctx.req);
     return;
   }
-  const modulePath = data.modulePath;
-  if (typeof modulePath !== "string" || !modulePath.trim()) {
-    jsonResponse(ctx.res, { error: "Missing or empty 'modulePath' field" }, 400, ctx.req);
-    return;
-  }
+  const modulePath = typeof data.modulePath === "string" ? data.modulePath : "";
   try {
     const depgraph = await getDepgraph();
     const branch = await getBranch(ctx.projectDir);