@ulpi/cli 0.1.0 → 0.1.2

package/README.md

@@ -40,20 +40,19 @@ cd your-project
 ulpi init
 ```
 
-That's it. ULPI detects your stack — language, framework, package manager, test runner, linter — and generates a tailored rules configuration. Hooks are installed into Claude Code automatically.
+ULPI detects your stack — language, framework, package manager, test runner, linter — and generates a tailored rules configuration. Hooks are installed into Claude Code automatically.
 
 Next time you start a Claude Code session, ULPI is active.
 
 ### Try it without installing
 
 ```bash
-cd your-project
 npx @ulpi/cli init
 ```
 
 ---
 
-## What You Get
+## Features
 
 ### Automatic Permissions
 
@@ -66,6 +65,12 @@ permissions:
     matcher: Bash
     command_pattern: "npm test|pnpm test|yarn test"
     decision: allow
+
+  auto-approve-git-read:
+    trigger: PermissionRequest
+    matcher: Bash
+    command_pattern: "git (status|log|diff|branch)"
+    decision: allow
 ```
 
 ### Guardrails
@@ -83,33 +88,140 @@ preconditions:
     matcher: "Write|Edit"
     message: "Read the file before editing it."
     requires_read: true
+
+  test-before-commit:
+    trigger: PreToolUse
+    matcher: Bash
+    command_pattern: "git commit"
+    message: "Run tests before committing."
+    requires:
+      tests_run: true
+```
+
+### Pipelines
+
+Chain multiple steps into automated workflows that run after tool execution.
+
+```yaml
+pipelines:
+  pre-commit-checks:
+    trigger: PostToolUse
+    matcher: Bash
+    command_pattern: "git commit"
+    steps:
+      - name: build
+        command: "pnpm -r build"
+      - name: test
+        command: "pnpm test"
+    block_on_failure: true
 ```
 
 ### Session Tracking
 
-ULPI knows what happened in your session — which files were read, which were written, which commands ran. Rules can use this context to make smarter decisions.
+ULPI tracks every action in real time — files read and written, commands executed, rules enforced, tests passed or failed. Session state powers smarter rule evaluation and feeds into history, memory, and the web dashboard.
+
+Each session follows a state machine (`idle` -> `active` -> `active_committed` -> `ended`) and logs up to 10,000 events as an append-only JSONL file.
 
 ### Web Dashboard
 
-A full web UI for managing rules, viewing live sessions, reviewing AI-generated plans, and browsing session history.
+A full web UI for managing rules, monitoring live sessions, reviewing plans and code, and browsing history.
 
 ```bash
 ulpi ui
 ```
 
-<!-- TODO: Add screenshot -->
+The dashboard shows:
+
+- **Guards** — Active rule counts, enforcement stats, rule breakdown by type
+- **Session** — Live session state with real-time event timeline (WebSocket)
+- **Review** — Pending plan and code reviews
+- **CodeMap** — Index status, file and chunk counts
+- **Memory** — Memory count, classified sessions, importance breakdown
+- **History** — Captured entries with AI enrichment status
+- **Skills** — Available bundled, project, and global skills
+- **Responses** — Notification channel configuration
 
 ### Plan & Code Review
 
-Review AI-generated plans and code changes in a dedicated UI before they execute. Annotate, approve, or reject with feedback that gets sent back to the agent.
+Review AI-generated plans and code changes in a browser-based UI before they execute.
+
+**Plan review** intercepts `ExitPlanMode` — the plan is parsed into sections, scored across 8 quality dimensions (test coverage, error handling, rollback strategy, scope clarity, and more), and presented for your review. You can annotate sections, assign priorities and risk levels, add per-section instructions, or make inline edits. Approve or deny with feedback that goes directly back to the agent.
+
+**Code review** intercepts `git commit` — the staged diff and commit message are shown for review with line-level annotation tools.
+
+Both flows use long-poll HTTP transport with a 10-minute timeout. If the server isn't running, the agent continues normally (fail-open).
 
-### Semantic Code Search
+### Semantic Code Search (CodeMap)
 
-ULPI indexes your codebase and exposes it as MCP tools that Claude Code can use for smarter, context-aware search — beyond simple grep.
+ULPI indexes your entire codebase using hybrid vector + BM25 search with AST-aware chunking. The agent gets smarter search than grep — it understands code semantics, symbol names, and file context.
+
+- **AST chunking** aligns chunks to function and class boundaries
+- **Symbol extraction** identifies functions, classes, interfaces, and types
+- **Hybrid ranking** fuses vector similarity (60%), keyword matching (25%), symbol boost (10%), and path relevance (5%)
+- **Incremental indexing** — only re-indexes changed files
+- **Per-branch indexes** — each git branch gets its own index
+- **Shadow branch export** — share indexes across machines via git
+
+Exposed to Claude Code as MCP tools: `search_code`, `search_symbols`, `get_file_summary`, `get_index_stats`, and `reindex`.
+
+```bash
+ulpi codemap init       # Index your codebase
+ulpi codemap search "authentication middleware"
+```
 
 ### Agent Memory
 
-Captures decisions, patterns, and lessons learned across sessions. Your AI agent builds institutional knowledge over time instead of starting fresh every conversation.
+Your AI agent builds institutional knowledge across sessions instead of starting fresh every conversation.
+
+ULPI captures session events, classifies them with an LLM into 8 memory types — **decisions**, **patterns**, **bug root causes**, **preferences**, **constraints**, **context**, **lessons**, and **relationships** — then stores them with vector embeddings for semantic search.
+
+At the start of each session, the most relevant memories are surfaced to the agent automatically.
+
+- **Deduplication** — new memories are compared against existing ones (0.92 similarity threshold) to prevent redundancy
+- **Importance-weighted ranking** — critical memories never decay; low-importance ones fade over time
+- **Redaction** — API keys, tokens, and secrets are stripped before storage
+- **Soft delete** — memories can be superseded rather than permanently removed
+
+Exposed as MCP tools: `search_memory`, `save_memory`, `get_timeline`, `get_session_context`, `forget`, and `memory_stats`.
+
+```bash
+ulpi memory search "authentication approach"
+ulpi memory status
+```
+
+### Session History
+
+Every coding session is recorded on a per-user orphan git branch (`ulpi/history-<username>`) — separate from your code, never touching your working tree.
+
+Each commit gets a structured JSON entry with:
+
+- Git metadata (SHA, message, author, branch, parents)
+- Diff statistics (files changed, insertions, deletions, per-file breakdown)
+- Session summary (files read/written, commands run, rules enforced)
+- Hook-derived analytics (rule evaluations, permission decisions, tool usage)
+- AI enrichment (summary, intent, challenges, learnings, recommendations)
+- Review plan snapshots and session transcripts
+
+```bash
+ulpi history init         # Create the history branch
+ulpi history list         # Browse captured sessions
+ulpi history enrich --all # AI-enrich all entries
+```
+
+### Notifications
+
+Route events to desktop notifications, webhooks, terminal bells, or log files based on classification rules. Built-in deduplication prevents notification storms.
+
+### Templates & Skills
+
+ULPI ships with **28 built-in templates** for popular stacks — Node.js, Python, Go, Rust, Next.js, Express, Laravel, Django, FastAPI, Prisma, Docker, and more.
+
+**Skills** are injectable markdown guides that ULPI attaches to blocked tool messages — teaching the agent how to fix the issue instead of just blocking it.
+
+```bash
+ulpi templates list
+ulpi skills list
+```
 
 ---
 
@@ -143,12 +255,12 @@ permissions:
     matcher: Bash
     command_pattern: "git (status|log|diff|branch)"
     decision: allow
-```
-
-ULPI ships with **28 built-in templates** for popular stacks — Node.js, Python, Go, Rust, Next.js, Laravel, Django, FastAPI, and more.
 
-```bash
-ulpi templates list
+review:
+  enabled: true
+  plan_review: true
+  code_review: true
+  auto_open_browser: true
 ```
 
 ---
@@ -179,12 +291,19 @@ ulpi templates list
 
 ## How It Works
 
-ULPI uses [Claude Code hooks](https://docs.anthropic.com/en/docs/claude-code/hooks) — lifecycle events that fire before and after every tool execution:
+ULPI uses [Claude Code hooks](https://docs.anthropic.com/en/docs/claude-code/hooks) — lifecycle events that fire before and after every tool execution.
+
+Seven hooks intercept the full session lifecycle:
 
-1. **Before a tool runs**, ULPI checks your rules. Should this file edit be allowed? Has the file been read first? Is this command safe?
-2. **When a permission is requested**, ULPI decides automatically based on your rules — allow, deny, or ask the user.
-3. **After a tool runs**, ULPI updates session state and runs any postconditions you've defined.
-4. **At session boundaries**, ULPI captures history, classifies memories, and indexes code changes.
+| Hook | When | What ULPI Does |
+|------|------|----------------|
+| **SessionStart** | Claude Code session begins | Detect stack, capture branch/HEAD, surface memories, import CodeMap index |
+| **PreToolUse** | Before any tool runs | Evaluate preconditions, block dangerous commands, intercept git commits for code review |
+| **PostToolUse** | After a tool completes | Track files/commands, run postconditions, capture history on new commits, export CodeMap on git push |
+| **PermissionRequest** | Tool needs approval | Auto-approve or deny based on rules, intercept ExitPlanMode for plan review |
+| **Notification** | Event notification | Classify and route to desktop, webhook, terminal, or log channels |
+| **Stop** | Session stopping | Final checks (warn about missing tests/lint) |
+| **SessionEnd** | Session complete | Persist summary, capture commits to history, classify memories, export indexes |
 
 If ULPI ever encounters an error, it fails open — Claude Code continues normally. Your agent is never blocked by a bug in ULPI.
 

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-PKD4ASEM.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.0";
+    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);