@ulpi/cli 0.1.1 → 0.1.3

package/dist/{memory-J3G24QHS.js → memory-Y6OZTXJ2.js}

@@ -25,6 +25,8 @@ async function runMemory(args, projectDir) {
       return await enableSubcommand(projectDir);
     case "disable":
       return await disableSubcommand(projectDir);
+    case "reindex":
+      return await reindexSubcommand(projectDir);
     default:
       console.log(`
 Usage: ulpi memory <subcommand>
@@ -37,15 +39,18 @@ Subcommands:
   export                  Push memories to git branch
   import                  Pull memories from git branch
   serve                   Start MCP server (stdio)
-  classify [session-id]   Run classifier on a captured session
+  classify [session-id]   Classify session(s) \u2014 all unclassified if no ID given
+    --branch <name>       Only classify sessions from this branch
+    --export              Export memories to git branch after classification
   enable                  Enable memory capture
   disable                 Disable memory capture
+  reindex                 Rebuild vector index (fixes dimension mismatches)
 `.trim());
   }
 }
 async function initSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Initialize\n"));
-  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, saveMemoryConfig, DEFAULT_MEMORY_CONFIG } = await import("./dist-GJYT2OQV.js");
   const { projectMemoryDir } = await import("./dist-RKOGLK7R.js");
   const fs = await import("fs");
   if (isMemoryInitialized(projectDir)) {
@@ -99,7 +104,7 @@ async function searchSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Searching memories...").start();
   try {
-    const { searchMemory, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+    const { searchMemory, isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
     if (!isMemoryInitialized(projectDir)) {
       spinner.fail("Memory not initialized");
       console.log(chalk.dim("Run 'ulpi memory init' first."));
@@ -165,7 +170,7 @@ async function rememberSubcommand(args, projectDir) {
     console.log(chalk.dim('\nExample: ulpi memory remember "Always run tests before committing" --type PREFERENCE --importance high'));
     return;
   }
-  const { isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -185,7 +190,7 @@ async function rememberSubcommand(args, projectDir) {
   const ora = (await import("ora")).default;
   const spinner = ora("Storing memory...").start();
   try {
-    const { generateMemoryId, rememberMemory } = await import("./dist-R5F4MX3I.js");
+    const { generateMemoryId, rememberMemory } = await import("./dist-GJYT2OQV.js");
     const now = (/* @__PURE__ */ new Date()).toISOString();
     const entry = {
       id: generateMemoryId(memType, text),
@@ -211,7 +216,7 @@ async function rememberSubcommand(args, projectDir) {
   }
 }
 async function statusSubcommand(projectDir) {
-  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, getMemoryStats, isMemoryEnabled, loadMemoryConfig } = await import("./dist-GJYT2OQV.js");
   console.log(chalk.bold("\nAgent Memory Status\n"));
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.yellow("  Not initialized"));
@@ -252,17 +257,18 @@ async function statusSubcommand(projectDir) {
 }
 async function exportSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Export\n"));
-  const { isMemoryInitialized, exportMemories } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, exportMemories } = await import("./dist-GJYT2OQV.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
   }
   try {
-    const result = exportMemories(projectDir);
+    const result = await exportMemories(projectDir);
     console.log(chalk.green("\u2713 Export complete"));
     console.log(chalk.dim(`  Branch:   ${result.branchName}`));
     console.log(chalk.dim(`  Commit:   ${result.commitSha.slice(0, 8)}`));
     console.log(chalk.dim(`  Memories: ${result.memoriesExported}`));
+    console.log(chalk.dim(`  Files:    ${result.filesExported}`));
     console.log("");
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -271,15 +277,16 @@ async function exportSubcommand(projectDir) {
 }
 async function importSubcommand(projectDir) {
   console.log(chalk.bold("\nAgent Memory -- Import\n"));
-  const { importMemories } = await import("./dist-R5F4MX3I.js");
+  const { importMemories } = await import("./dist-GJYT2OQV.js");
   try {
-    const result = importMemories(projectDir);
+    const result = await importMemories(projectDir);
     if (!result.success) {
       console.log(chalk.yellow(`Import skipped: ${result.message}`));
       return;
     }
     console.log(chalk.green("\u2713 Import complete"));
     console.log(chalk.dim(`  Imported: ${result.memoriesImported}`));
+    console.log(chalk.dim(`  Files:    ${result.filesImported}`));
     console.log(chalk.dim(`  ${result.message}`));
     console.log("");
   } catch (err) {
@@ -288,34 +295,213 @@ async function importSubcommand(projectDir) {
   }
 }
 async function serveSubcommand(projectDir) {
-  const { isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
   if (!isMemoryInitialized(projectDir)) {
     console.error(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     process.exit(1);
   }
   console.error(chalk.dim("[memory-mcp] Starting MCP server..."));
   console.error(chalk.dim(`[memory-mcp] Project: ${projectDir}`));
-  const { startMemoryMcpServer } = await import("./dist-7LHZ65GC.js");
+  const { startMemoryMcpServer } = await import("./dist-CS2VKNYS.js");
   await startMemoryMcpServer({ projectDir });
 }
 async function classifySubcommand(args, projectDir) {
-  const { isMemoryInitialized, listCapturedSessions, classifySession } = await import("./dist-R5F4MX3I.js");
+  const { isMemoryInitialized, listCapturedSessions, classifySession, loadWatermark, writeClassifyBatchProgress, clearClassifyBatchProgress } = await import("./dist-GJYT2OQV.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
   }
-  let sessionId = args.filter((a) => !a.startsWith("--"))[0];
-  if (!sessionId) {
-    const sessions = listCapturedSessions(projectDir);
-    if (sessions.length === 0) {
+  const ora = (await import("ora")).default;
+  const doExport = args.includes("--export");
+  const isBg = !!process.env.ULPI_BG_CLASSIFY;
+  let branchFilter;
+  const branchFlagIdx = args.indexOf("--branch");
+  if (branchFlagIdx !== -1 && args[branchFlagIdx + 1]) {
+    branchFilter = args[branchFlagIdx + 1];
+  }
+  let sessionId;
+  const sessionFlagIdx = args.indexOf("--session");
+  if (sessionFlagIdx !== -1 && args[sessionFlagIdx + 1]) {
+    sessionId = args[sessionFlagIdx + 1];
+  } else {
+    const skipNext = /* @__PURE__ */ new Set();
+    if (sessionFlagIdx !== -1) skipNext.add(sessionFlagIdx + 1);
+    if (branchFlagIdx !== -1) skipNext.add(branchFlagIdx + 1);
+    for (let i = 0; i < args.length; i++) {
+      if (skipNext.has(i) || args[i].startsWith("--")) continue;
+      sessionId = args[i];
+      break;
+    }
+  }
+  if (sessionId) {
+    if (isBg) {
+      try {
+        await classifySession(projectDir, sessionId);
+      } catch {
+      }
+      if (doExport) {
+        try {
+          const { exportMemories } = await import("./dist-GJYT2OQV.js");
+          await exportMemories(projectDir);
+        } catch {
+        }
+      }
+      return;
+    }
+    await classifySingleSession(projectDir, sessionId, classifySession);
+    if (doExport) {
+      try {
+        const { exportMemories } = await import("./dist-GJYT2OQV.js");
+        const result = await exportMemories(projectDir);
+        console.log(chalk.green(`\u2713 Exported ${result.memoriesExported} memories to ${result.branchName}`));
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        console.log(chalk.yellow(`  Export skipped: ${msg}`));
+      }
+    }
+    return;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  let sessions = listCapturedSessions(projectDir);
+  if (sessions.length === 0) {
+    writeClassifyBatchProgress(projectDir, {
+      status: "done",
+      total: 0,
+      completed: 0,
+      failed: 0,
+      memoriesFound: 0,
+      branch: branchFilter,
+      startedAt: now,
+      updatedAt: now
+    });
+    if (!isBg) {
       console.log(chalk.yellow("No captured sessions found."));
       console.log(chalk.dim("Sessions are captured automatically at session end when memory is enabled."));
+    }
+    return;
+  }
+  if (branchFilter) {
+    sessions = sessions.filter((s) => s.branch === branchFilter);
+    if (sessions.length === 0) {
+      writeClassifyBatchProgress(projectDir, {
+        status: "done",
+        total: 0,
+        completed: 0,
+        failed: 0,
+        memoriesFound: 0,
+        branch: branchFilter,
+        startedAt: now,
+        updatedAt: now
+      });
+      if (!isBg) {
+        console.log(chalk.yellow(`No captured sessions found for branch "${branchFilter}".`));
+      }
       return;
     }
-    const latest = sessions[sessions.length - 1];
-    sessionId = latest.sessionId;
-    console.log(chalk.dim(`Using latest session: ${sessionId}`));
   }
+  const unclassified = sessions.filter((s) => {
+    const wm = loadWatermark(projectDir, s.sessionId);
+    return !wm;
+  });
+  if (unclassified.length === 0) {
+    writeClassifyBatchProgress(projectDir, {
+      status: "done",
+      total: 0,
+      completed: 0,
+      failed: 0,
+      memoriesFound: 0,
+      branch: branchFilter,
+      startedAt: now,
+      updatedAt: now
+    });
+    if (!isBg) {
+      console.log(chalk.yellow("All captured sessions have been classified."));
+      console.log(chalk.dim(`  Total sessions: ${sessions.length}`));
+      if (branchFilter) console.log(chalk.dim(`  Branch filter: ${branchFilter}`));
+    }
+    return;
+  }
+  if (!isBg) {
+    console.log(chalk.bold(`
+Agent Memory -- Classify Sessions
+`));
+    console.log(chalk.dim(`  Found ${unclassified.length} unclassified session(s)${branchFilter ? ` on branch "${branchFilter}"` : ""}
+`));
+  }
+  let totalExtracted = 0;
+  let totalStored = 0;
+  let succeeded = 0;
+  let failed = 0;
+  const startedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeClassifyBatchProgress(projectDir, {
+    status: "classifying",
+    total: unclassified.length,
+    completed: 0,
+    failed: 0,
+    memoriesFound: 0,
+    branch: branchFilter,
+    startedAt,
+    updatedAt: startedAt
+  });
+  for (let i = 0; i < unclassified.length; i++) {
+    const session = unclassified[i];
+    const label = `[${i + 1}/${unclassified.length}] ${session.sessionId.slice(0, 8)}... (${session.filesWritten} writes, ${session.commandsRun} cmds)`;
+    const spinner = isBg ? null : ora(label).start();
+    writeClassifyBatchProgress(projectDir, {
+      status: "classifying",
+      total: unclassified.length,
+      completed: i,
+      failed,
+      memoriesFound: totalStored,
+      current: session.sessionId,
+      branch: branchFilter,
+      startedAt,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    try {
+      const result = await classifySession(projectDir, session.sessionId, (progress) => {
+        if (!spinner) return;
+        const pct = progress.total > 0 ? ` (${Math.round(progress.current / progress.total * 100)}%)` : "";
+        spinner.text = `${label} \u2014 ${progress.message}${pct}`;
+      });
+      totalExtracted += result.memoriesExtracted;
+      totalStored += result.memoriesStored;
+      succeeded++;
+      if (spinner) {
+        if (result.memoriesStored > 0) {
+          spinner.succeed(`${label} \u2014 ${result.memoriesStored} memories stored`);
+        } else {
+          spinner.info(`${label} \u2014 no new memories`);
+        }
+      }
+    } catch (err) {
+      failed++;
+      const message = err instanceof Error ? err.message : String(err);
+      if (spinner) spinner.fail(`${label} \u2014 ${message}`);
+    }
+  }
+  writeClassifyBatchProgress(projectDir, {
+    status: failed === unclassified.length ? "error" : "done",
+    total: unclassified.length,
+    completed: succeeded,
+    failed,
+    memoriesFound: totalStored,
+    branch: branchFilter,
+    startedAt,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    error: failed === unclassified.length ? "All sessions failed classification" : void 0
+  });
+  if (!isBg) {
+    console.log("");
+    console.log(chalk.bold("  Summary"));
+    console.log(chalk.dim(`    Sessions processed: ${succeeded}/${unclassified.length}`));
+    if (failed > 0) console.log(chalk.red(`    Failed:             ${failed}`));
+    console.log(chalk.dim(`    Memories extracted: ${totalExtracted}`));
+    console.log(chalk.dim(`    Memories stored:    ${totalStored}`));
+    console.log("");
+  }
+}
+async function classifySingleSession(projectDir, sessionId, classifySession) {
   console.log(chalk.bold(`
 Agent Memory -- Classify Session
 `));
@@ -340,7 +526,7 @@ Agent Memory -- Classify Session
   }
 }
 async function enableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -351,7 +537,7 @@ async function enableSubcommand(projectDir) {
   console.log(chalk.green("\u2713 Memory capture enabled"));
 }
 async function disableSubcommand(projectDir) {
-  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-R5F4MX3I.js");
+  const { loadMemoryConfig, saveMemoryConfig, isMemoryInitialized } = await import("./dist-GJYT2OQV.js");
   if (!isMemoryInitialized(projectDir)) {
     console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
     return;
@@ -361,6 +547,29 @@ async function disableSubcommand(projectDir) {
   saveMemoryConfig(projectDir, config);
   console.log(chalk.yellow("\u2713 Memory capture disabled"));
 }
+async function reindexSubcommand(projectDir) {
+  const { isMemoryInitialized, reindexMemories } = await import("./dist-GJYT2OQV.js");
+  if (!isMemoryInitialized(projectDir)) {
+    console.log(chalk.red("Error: Memory not initialized. Run 'ulpi memory init' first."));
+    return;
+  }
+  console.log(chalk.bold("\nAgent Memory -- Reindex\n"));
+  const ora = (await import("ora")).default;
+  const spinner = ora("Rebuilding vector index...").start();
+  try {
+    const result = await reindexMemories(projectDir, (progress) => {
+      const pct = progress.total > 0 ? ` (${Math.round(progress.current / progress.total * 100)}%)` : "";
+      spinner.text = `${progress.message}${pct}`;
+    });
+    spinner.succeed("Reindex complete");
+    console.log(chalk.dim(`  Entries reindexed: ${result.reindexed}`));
+    console.log(chalk.dim(`  Duration:          ${(result.durationMs / 1e3).toFixed(1)}s`));
+    console.log("");
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    spinner.fail(`Reindex failed: ${message}`);
+  }
+}
 function truncate(str, maxLen) {
   if (str.length <= maxLen) return str;
   return str.slice(0, maxLen - 3) + "...";

package/dist/{server-MOYPE4SM-N7SE2AN7.js → server-USLHY6GH-AEOJC5ST.js}

@@ -1,6 +1,6 @@
 import {
   createApiServer
-} from "./chunk-Q4HIY43N.js";
+} from "./chunk-2VYFVYJL.js";
 import "./chunk-MIAQVCFW.js";
 import "./chunk-2MZER6ND.js";
 import "./chunk-3SBPZRB5.js";
@@ -8,7 +8,7 @@ import "./chunk-2CLNOKPA.js";
 import "./chunk-SPOI23SB.js";
 import "./chunk-6OCEY7JY.js";
 import "./chunk-SIAQVRKG.js";
-import "./chunk-NNUWU6CV.js";
+import "./chunk-JGBXM5NC.js";
 import "./chunk-YM2HV4IA.js";
 import "./chunk-KIKPIH6N.js";
 import "./chunk-7LXY5UVC.js";