@ulpi/cli 0.1.4 → 0.1.6

package/dist/{chunk-PDR55ZNW.js → chunk-BFEKZZHM.js}

@@ -1,22 +1,20 @@
 import {
   createEmbedder,
+  embedAll,
+  embedOne,
   loadCodemapIgnore,
   matchesDenyPattern
-} from "./chunk-5J6NLQUN.js";
+} from "./chunk-IV6MWETF.js";
 import {
   commitInWorktree,
   copyAndStage,
   historyBranchExists,
   withWorktree,
   writeAndStage
-} from "./chunk-JGBXM5NC.js";
+} from "./chunk-3WB5CXH4.js";
 import {
   readEvents
-} from "./chunk-YM2HV4IA.js";
-import {
-  ClassificationResultSchema,
-  MemoryConfigSchema
-} from "./chunk-74WVVWJ4.js";
+} from "./chunk-SEU7WWNQ.js";
 import {
   getMemoryBranch,
   memoryConfigFile,
@@ -26,7 +24,11 @@ import {
   memoryStatsFile,
   memoryWatermarksDir,
   projectMemoryDir
-} from "./chunk-7LXY5UVC.js";
+} from "./chunk-C7CLUQI6.js";
+import {
+  ClassificationResultSchema,
+  MemoryConfigSchema
+} from "./chunk-YOKL7RB5.js";
 
 // ../../packages/memory-engine/dist/index.js
 import * as fs from "fs";
@@ -57,6 +59,8 @@ import * as os3 from "os";
 import * as path9 from "path";
 import { readFileSync as readFileSync8, writeFileSync as writeFileSync8, unlinkSync as unlinkSync3, existsSync as existsSync10 } from "fs";
 import { join as join8 } from "path";
+import * as fs10 from "fs";
+import * as path10 from "path";
 var DEFAULT_MEMORY_CONFIG = MemoryConfigSchema.parse({});
 function loadMemoryConfig(projectDir) {
   const configPath = memoryConfigFile(projectDir);
@@ -807,7 +811,7 @@ async function searchMemory(projectDir, options) {
   const config = loadMemoryConfig(projectDir);
   const limit = options.limit ?? 10;
   const embedder = await createEmbedder(config.embedding);
-  const [queryVector] = await embedder.embed([options.query]);
+  const queryVector = await embedOne(embedder, options.query);
   acquireMemoryLock(projectDir);
   let results;
   let trimmed;
@@ -1162,7 +1166,7 @@ async function classifySession(projectDir, sessionId, onProgress) {
   });
   const embedder = await createEmbedder(config.embedding);
   const texts = allMemories.map((m) => m.summary);
-  const embeddings = await embedWithBatch(embedder, texts);
+  const embeddings = await embedAll(embedder, texts);
   onProgress?.({
     phase: "storing",
     current: 0,
@@ -1250,20 +1254,12 @@ async function reindexMemories(projectDir, onProgress) {
   if (entries.length === 0) {
     return { reindexed: 0, durationMs: Date.now() - startMs };
   }
+  const total = entries.length;
   onProgress?.({
     phase: "embedding",
     current: 0,
-    total: entries.length,
-    message: `Re-embedding ${entries.length} memories...`
-  });
-  const embedder = await createEmbedder(config.embedding);
-  const texts = entries.map((m) => m.summary);
-  const embeddings = await embedWithBatch(embedder, texts);
-  onProgress?.({
-    phase: "storing",
-    current: 0,
-    total: entries.length,
-    message: "Rebuilding vector index..."
+    total,
+    message: `Re-embedding ${total} memories...`
   });
   acquireMemoryLock(projectDir);
   try {
@@ -1273,52 +1269,52 @@ async function reindexMemories(projectDir, onProgress) {
     }
     const store = new MemoryVectorStore(projectDir);
     await store.initialize();
-    const vectorItems = entries.map((entry, i) => ({
-      id: entry.id,
-      vector: embeddings[i],
-      metadata: {
-        id: entry.id,
-        type: entry.type,
-        importance: entry.importance,
-        snippet: entry.summary.slice(0, 200),
-        createdAt: entry.createdAt,
-        tags: entry.tags.join(",")
+    const embedder = await createEmbedder(config.embedding);
+    const texts = entries.map((m) => m.summary);
+    await embedAll(embedder, texts, {
+      onProgress: (info) => {
+        onProgress?.({
+          phase: "embedding",
+          current: info.current,
+          total: info.total,
+          message: info.message
+        });
+      },
+      onBatch: async (embeddings, startIndex, count) => {
+        const vectorItems = [];
+        for (let i = 0; i < count; i++) {
+          const entry = entries[startIndex + i];
+          vectorItems.push({
+            id: entry.id,
+            vector: embeddings[i],
+            metadata: {
+              id: entry.id,
+              type: entry.type,
+              importance: entry.importance,
+              snippet: entry.summary.slice(0, 200),
+              createdAt: entry.createdAt,
+              tags: entry.tags.join(",")
+            }
+          });
+        }
+        await store.upsertItems(vectorItems);
       }
-    }));
-    await store.upsertItems(vectorItems);
+    });
     onProgress?.({
       phase: "finalizing",
-      current: entries.length,
-      total: entries.length,
-      message: `Re-indexed ${entries.length} memories`
+      current: total,
+      total,
+      message: `Re-indexed ${total} memories`
     });
-    return { reindexed: entries.length, durationMs: Date.now() - startMs };
+    return { reindexed: total, durationMs: Date.now() - startMs };
   } finally {
     releaseMemoryLock(projectDir);
   }
 }
-async function embedWithBatch(embedder, texts) {
-  if (texts.length === 0) return [];
-  if (embedder.supportsBatch && embedder.submitBatch && embedder.pollBatch) {
-    const batchId = await embedder.submitBatch(texts);
-    const POLL_MS = 2e3;
-    while (true) {
-      const status = await embedder.pollBatch(batchId);
-      if (status.status === "completed" && status.results) {
-        return status.results;
-      }
-      if (status.status === "failed") {
-        throw new Error(`Batch embedding failed (batch ${batchId})`);
-      }
-      await new Promise((resolve2) => setTimeout(resolve2, POLL_MS));
-    }
-  }
-  return embedder.embed(texts);
-}
 async function rememberMemory(projectDir, entry) {
   const config = loadMemoryConfig(projectDir);
   const embedder = await createEmbedder(config.embedding);
-  const [vector] = await embedder.embed([entry.summary]);
+  const vector = await embedOne(embedder, entry.summary);
   acquireMemoryLock(projectDir);
   try {
     const store = new MemoryVectorStore(projectDir);
@@ -1626,6 +1622,226 @@ function clearClassifyBatchProgress(projectDir) {
   } catch {
   }
 }
+var NOISE_EVENT_TYPES = /* @__PURE__ */ new Set([
+  "agent:output",
+  "worker-progress",
+  "engine:paused",
+  "engine:resumed",
+  "iteration:retrying",
+  "iteration:rate-limited",
+  "agent:recovery-attempted"
+]);
+function jobEventToClassificationEvent(event) {
+  const ts = event.ts ?? event.timestamp ?? (/* @__PURE__ */ new Date()).toISOString();
+  const type = event.type;
+  switch (type) {
+    // --- Loop engine events ---
+    case "engine:started":
+      return {
+        ts,
+        event: "engine_started",
+        hookEvent: "SessionStart",
+        message: `Loop started with ${event.totalTasks ?? 0} tasks`
+      };
+    case "iteration:started":
+      return {
+        ts,
+        event: "iteration_started",
+        hookEvent: "PreToolUse",
+        message: `Starting task: ${taskTitle(event)}`
+      };
+    case "iteration:completed": {
+      const result = event.result;
+      const durMs = result?.durationMs ?? event.durationMs ?? 0;
+      return {
+        ts,
+        event: "iteration_completed",
+        hookEvent: "PostToolUse",
+        message: `Task completed: ${taskTitle(event)} in ${durMs}ms`
+      };
+    }
+    case "iteration:failed":
+      return {
+        ts,
+        event: "iteration_failed",
+        hookEvent: "PostToolUse",
+        message: `Task failed: ${taskTitle(event)} \u2014 ${event.error ?? "unknown error"}`
+      };
+    case "task:skipped":
+      return {
+        ts,
+        event: "task_skipped",
+        hookEvent: "PostToolUse",
+        message: `Task skipped: ${taskTitle(event)} \u2014 ${event.reason ?? ""}`
+      };
+    case "task:auto-committed":
+      return {
+        ts,
+        event: "git_commit",
+        hookEvent: "PostToolUse",
+        command: "git commit",
+        message: String(event.commitMessage ?? "")
+      };
+    case "task:auto-commit-failed":
+      return {
+        ts,
+        event: "auto_commit_failed",
+        hookEvent: "PostToolUse",
+        message: `Auto-commit failed: ${event.error ?? "unknown"}`
+      };
+    case "agent:switched":
+      return {
+        ts,
+        event: "agent_switched",
+        hookEvent: "Notification",
+        message: `Switched ${event.previousAgent ?? "?"} \u2192 ${event.newAgent ?? "?"}: ${event.reason ?? ""}`
+      };
+    case "agent:all-limited":
+      return {
+        ts,
+        event: "all_agents_limited",
+        hookEvent: "Notification",
+        message: `All agents rate-limited: ${Array.isArray(event.triedAgents) ? event.triedAgents.join(", ") : ""}`
+      };
+    case "engine:error":
+      return {
+        ts,
+        event: "engine_error",
+        hookEvent: "Notification",
+        message: `Engine error: ${event.error ?? "unknown"}`
+      };
+    case "engine:stopped":
+      return {
+        ts,
+        event: "engine_stopped",
+        hookEvent: "SessionEnd",
+        message: `Engine stopped: ${event.reason ?? "completed"}`
+      };
+    // --- Parallel engine events ---
+    case "worker-started":
+      return {
+        ts,
+        event: "worker_started",
+        hookEvent: "PreToolUse",
+        message: `Parallel worker started: ${event.taskId ?? event.workerId ?? ""}`
+      };
+    case "worker-completed":
+      return {
+        ts,
+        event: "worker_completed",
+        hookEvent: "PostToolUse",
+        message: `Parallel worker completed: ${event.taskId ?? event.workerId ?? ""}`
+      };
+    case "worker-failed":
+      return {
+        ts,
+        event: "worker_failed",
+        hookEvent: "PostToolUse",
+        message: `Parallel worker failed: ${event.error ?? "unknown error"}`
+      };
+    case "merge-completed":
+      return {
+        ts,
+        event: "merge_completed",
+        hookEvent: "PostToolUse",
+        command: "git merge",
+        message: `Merged ${event.taskId ?? ""}`
+      };
+    case "merge-failed":
+      return {
+        ts,
+        event: "merge_failed",
+        hookEvent: "PostToolUse",
+        message: `Merge failed: ${event.taskId ?? ""} \u2014 ${event.error ?? "unknown error"}`
+      };
+    case "group-completed": {
+      const completed = event.tasksCompleted ?? 0;
+      const failed = event.tasksFailed ?? 0;
+      return {
+        ts,
+        event: "group_completed",
+        hookEvent: "PostToolUse",
+        message: `Group ${event.groupIndex ?? "?"}: ${completed} ok, ${failed} failed`
+      };
+    }
+    case "all-completed":
+      return {
+        ts,
+        event: "all_completed",
+        hookEvent: "SessionEnd",
+        message: `Parallel run done: ${event.totalCompleted ?? 0} tasks`
+      };
+    case "all:complete":
+      return {
+        ts,
+        event: "all_completed",
+        hookEvent: "SessionEnd",
+        message: `All tasks complete: ${event.totalCompleted ?? 0} completed in ${event.totalIterations ?? 0} iterations`
+      };
+    // Also capture task:completed / task:failed from loop
+    case "task:completed":
+      return {
+        ts,
+        event: "task_completed",
+        hookEvent: "PostToolUse",
+        message: `Task completed: ${taskTitle(event)}`
+      };
+    case "task:failed":
+      return {
+        ts,
+        event: "task_failed",
+        hookEvent: "PostToolUse",
+        message: `Task failed: ${taskTitle(event)} \u2014 ${event.error ?? ""}`
+      };
+    default:
+      return null;
+  }
+}
+function taskTitle(event) {
+  const task = event.task;
+  if (task) {
+    return String(task.title ?? task.id ?? "unknown");
+  }
+  return String(event.taskId ?? "unknown");
+}
+function captureJobForClassification(projectDir, jobId, jobEvents, meta) {
+  const sessionId = jobId;
+  const dir = path10.join(memoryHistoryDir(projectDir), `sess_${sessionId}`);
+  fs10.mkdirSync(dir, { recursive: true });
+  const config = loadMemoryConfig(projectDir);
+  const redactPatterns = config.redactPatterns;
+  const classificationEvents = [];
+  for (const event of jobEvents) {
+    const type = event.type;
+    if (NOISE_EVENT_TYPES.has(type)) continue;
+    const ce = jobEventToClassificationEvent(event);
+    if (!ce) continue;
+    if (ce.command && redactPatterns.length > 0) {
+      ce.command = redactContent(ce.command, redactPatterns);
+    }
+    if (ce.message && redactPatterns.length > 0) {
+      ce.message = redactContent(ce.message, redactPatterns);
+    }
+    classificationEvents.push(ce);
+  }
+  if (classificationEvents.length === 0) return;
+  const eventsPath = path10.join(dir, "events.jsonl");
+  const lines = classificationEvents.map((ce) => JSON.stringify(ce));
+  fs10.writeFileSync(eventsPath, lines.join("\n") + "\n", "utf-8");
+  const sessionMeta = {
+    sessionId,
+    projectDir,
+    startedAt: meta.startedAt,
+    endedAt: meta.endedAt,
+    filesRead: 0,
+    filesWritten: meta.tasksCompleted,
+    commandsRun: meta.totalIterations,
+    transcriptCaptured: false,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const metaPath = path10.join(dir, "meta.json");
+  fs10.writeFileSync(metaPath, JSON.stringify(sessionMeta, null, 2) + "\n", "utf-8");
+}
 
 export {
   DEFAULT_MEMORY_CONFIG,
@@ -1677,5 +1893,6 @@ export {
   importMemories,
   writeClassifyBatchProgress,
   readClassifyBatchProgress,
-  clearClassifyBatchProgress
+  clearClassifyBatchProgress,
+  captureJobForClassification
 };