@ulpi/cli 0.1.5 → 0.1.6

package/dist/{chunk-SIAQVRKG.js → chunk-5MI5GIXM.js}

@@ -1630,9 +1630,10 @@ var PipelineRuleInputSchema = external_exports.object({
   priority: external_exports.number().int().nonnegative().default(100)
 });
 var NotifyChannelSchema = external_exports.object({
-  type: external_exports.enum(["desktop", "webhook", "log", "terminal"]),
+  type: external_exports.enum(["desktop", "webhook", "log", "terminal", "sound"]),
   sound: external_exports.boolean().optional(),
   sound_file: external_exports.string().optional(),
+  sound_name: external_exports.string().optional(),
   url: external_exports.string().optional(),
   template: external_exports.string().optional(),
   path: external_exports.string().optional(),
@@ -1917,6 +1918,9 @@ function buildPermissionOutput(decision, reason, hookEventName = "PreToolUse") {
     }
   };
 }
+function evaluatePermission(rule) {
+  return buildPermissionOutput(rule.decision, rule.message);
+}
 function collectPostconditions(input, rules, projectDir) {
   const results = [];
   const toolName = input.tool_name ?? "";
@@ -2153,11 +2157,53 @@ function evaluateRules(hookInput, rules, state, projectDir) {
   }
   return allowResult(matchedRules, postconditionCommands, postconditionResults);
 }
+function resolveVariables(template, config, input) {
+  const pm = config.package_manager ?? "npm";
+  const vars = {
+    file_path: input?.tool_input?.file_path,
+    command: input?.tool_input?.command,
+    package_manager: pm,
+    test_command: config.test_command ?? `${pm} test`,
+    lint_command: config.lint_command ?? `${pm} lint`,
+    build_command: config.build_command ?? `${pm} build`,
+    format_command: config.format_command,
+    project_name: config.name
+  };
+  return template.replace(/\{(\w+)\}/g, (_match, key) => {
+    const value = vars[key];
+    return value !== void 0 ? value : `{${key}}`;
+  });
+}
 
 export {
+  HookEventSchema,
+  SessionStateFlagSchema,
+  RuleSourceSchema,
+  PermissionDecisionSchema,
+  PipelineOnFailureSchema,
+  StackConfigSchema,
+  PreconditionRuleInputSchema,
+  PostconditionRuleInputSchema,
+  PermissionRuleInputSchema,
+  PipelineStepSchema,
+  PipelineRuleInputSchema,
+  NotifyChannelSchema,
+  EventResponseConfigSchema,
   ResponseConfigSchema,
+  ReviewSettingsConfigSchema,
+  RulesConfigSchema,
   parseRules,
   loadRulesSync,
+  matchesTool,
+  normalizePath,
   matchesFilePattern,
-  evaluateRules
+  matchesCommand,
+  isDangerousCommand,
+  checkPrecondition,
+  buildPermissionOutput,
+  evaluatePermission,
+  collectPostconditions,
+  checkPipelinePrereqs,
+  evaluateRules,
+  resolveVariables
 };

package/dist/{chunk-KLEASXUR.js → chunk-6ZL6NXMV.js}

@@ -1,4 +1,4 @@
-// ../../packages/codemap-engine/dist/chunk-RU4VHMIP.js
+// ../../packages/embed-engine/dist/chunk-RU4VHMIP.js
 var DEFAULT_OLLAMA_URL = "http://localhost:11434";
 var MAX_RETRIES = 3;
 var RETRY_BASE_MS = 500;

package/dist/{chunk-AV5RB3N2.js → chunk-76D3BYJD.js}

@@ -1,7 +1,46 @@
+import {
+  external_exports
+} from "./chunk-KIKPIH6N.js";
+
 // ../../packages/ci-engine/dist/index.js
 import * as fs4 from "fs";
 import * as path3 from "path";
 import { execFileSync as execFileSync2 } from "child_process";
+var GITHUB_API = "https://api.github.com";
+async function githubFetch(path4, token, options) {
+  const url = `${GITHUB_API}${path4}`;
+  const res = await fetch(url, {
+    ...options,
+    headers: {
+      Accept: "application/vnd.github+json",
+      Authorization: `Bearer ${token}`,
+      "X-GitHub-Api-Version": "2022-11-28",
+      ...options?.headers ?? {}
+    }
+  });
+  if (!res.ok) {
+    const body = await res.text().catch(() => "");
+    throw new Error(
+      `GitHub API ${res.status}: ${path4} - ${body.slice(0, 200)}`
+    );
+  }
+  return res;
+}
+function extractDescription(desc) {
+  if (typeof desc === "string") return desc;
+  if (!desc || typeof desc !== "object") return void 0;
+  try {
+    return extractAdfText(desc);
+  } catch {
+    return void 0;
+  }
+}
+function extractAdfText(node) {
+  if (node.type === "text") return node.text ?? "";
+  const content = node.content;
+  if (!content) return "";
+  return content.map(extractAdfText).join("").trim();
+}
 function buildPrompt(config, context) {
   const sections = [];
   sections.push("# Task");
@@ -164,8 +203,17 @@ function getCredentialExpiry(blob) {
     }
   }
 }
+var PlanTierSchema = external_exports.enum([
+  "free",
+  "starter",
+  "pro",
+  "team",
+  "enterprise"
+]);
 
 export {
+  githubFetch,
+  extractDescription,
   buildPrompt,
   extractCredentials,
   validateCredentials,

package/dist/{chunk-DOIKS6C5.js → chunk-AWOSRA5F.js}

@@ -3,7 +3,7 @@ import {
   depgraphGraphFile,
   depgraphMetricsFile,
   depgraphPagerankFile
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
 // ../../packages/depgraph-engine/dist/index.js
 import { mkdirSync, readFileSync, writeFileSync } from "fs";

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

@@ -1,22 +1,20 @@
 import {
   createEmbedder,
+  embedAll,
+  embedOne,
   loadCodemapIgnore,
   matchesDenyPattern
-} from "./chunk-6OURRFP7.js";
+} from "./chunk-IV6MWETF.js";
 import {
   commitInWorktree,
   copyAndStage,
   historyBranchExists,
   withWorktree,
   writeAndStage
-} from "./chunk-L3PWNHSA.js";
+} from "./chunk-3WB5CXH4.js";
 import {
   readEvents
-} from "./chunk-26LLDX2T.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-DDRLI6JU.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
 };