@ulpi/cli 0.1.1 → 0.1.3

package/dist/chunk-G6SVZ4Q5.js

@@ -0,0 +1,122 @@
+// ../../packages/ci-engine/dist/index.js
+import * as fs4 from "fs";
+import * as path3 from "path";
+import { execFileSync as execFileSync2 } from "child_process";
+function buildPrompt(config, context) {
+  const sections = [];
+  sections.push("# Task");
+  sections.push("");
+  sections.push(config.instruction);
+  sections.push("");
+  if (context.prTitle || context.prBody) {
+    sections.push("# Pull Request Context");
+    sections.push("");
+    if (context.prTitle) sections.push(`**Title:** ${context.prTitle}`);
+    if (context.prBody) {
+      sections.push("");
+      sections.push(context.prBody);
+    }
+    sections.push("");
+  }
+  sections.push("# Branch Info");
+  sections.push("");
+  sections.push(`- **Working branch:** ${config.ref}`);
+  sections.push(`- **Base branch:** ${config.baseBranch}`);
+  sections.push(`- **Repository:** ${config.repoFullName}`);
+  sections.push("");
+  if (config.jiraContext || context.jiraContext) {
+    sections.push("# Jira Context");
+    sections.push("");
+    sections.push(config.jiraContext ?? context.jiraContext ?? "");
+    sections.push("");
+  }
+  sections.push("# Important Instructions");
+  sections.push("");
+  sections.push(
+    "- You are running in CI mode inside a worker container."
+  );
+  sections.push(
+    "- Work on the existing branch \u2014 do NOT create new branches."
+  );
+  sections.push(
+    "- Commit your changes with clear, descriptive commit messages."
+  );
+  sections.push("- Run tests if a test runner is configured.");
+  sections.push(
+    "- Do NOT push to the remote \u2014 the orchestrator will handle pushing."
+  );
+  sections.push("");
+  return sections.join("\n");
+}
+function extractCredentials(claudeConfigDir) {
+  const configDir = claudeConfigDir ?? path3.join(process.env.HOME ?? "", ".claude");
+  if (!fs4.existsSync(configDir)) {
+    throw new Error(
+      `Claude config directory not found: ${configDir}`
+    );
+  }
+  const tarOutput = execFileSync2(
+    "tar",
+    ["-czf", "-", "-C", configDir, "."],
+    {
+      encoding: "buffer",
+      timeout: 3e4,
+      maxBuffer: 50 * 1024 * 1024
+      // 50MB limit
+    }
+  );
+  return tarOutput.toString("base64");
+}
+function writeCredentials(blob, targetDir) {
+  fs4.mkdirSync(targetDir, { recursive: true });
+  const tarBuffer = Buffer.from(blob, "base64");
+  execFileSync2("tar", ["-xzf", "-", "-C", targetDir], {
+    input: tarBuffer,
+    timeout: 3e4
+  });
+}
+function validateCredentials(blob) {
+  const tmpDir = fs4.mkdtempSync("/tmp/ulpi-claude-check-");
+  try {
+    writeCredentials(blob, tmpDir);
+    const files = fs4.readdirSync(tmpDir);
+    return files.length > 0;
+  } catch {
+    return false;
+  } finally {
+    try {
+      fs4.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function getCredentialExpiry(blob) {
+  const tmpDir = fs4.mkdtempSync("/tmp/ulpi-claude-expiry-");
+  try {
+    writeCredentials(blob, tmpDir);
+    const authFile = path3.join(tmpDir, ".credentials.json");
+    if (fs4.existsSync(authFile)) {
+      try {
+        const data = JSON.parse(
+          fs4.readFileSync(authFile, "utf-8")
+        );
+        if (data.expiresAt) return data.expiresAt;
+        if (data.expires_at) return data.expires_at;
+      } catch {
+      }
+    }
+    return void 0;
+  } finally {
+    try {
+      fs4.rmSync(tmpDir, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+
+export {
+  buildPrompt,
+  extractCredentials,
+  validateCredentials,
+  getCredentialExpiry
+};

package/dist/{chunk-NNUWU6CV.js → chunk-JGBXM5NC.js}

@@ -345,6 +345,47 @@ function listRecentCommits(projectDir, maxCount = 20) {
     return [];
   }
 }
+function listBranchOnlyCommits(projectDir, maxCount = 50) {
+  try {
+    let currentBranch;
+    try {
+      currentBranch = gitExec(projectDir, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    } catch {
+      return listRecentCommits(projectDir, maxCount);
+    }
+    let defaultBranch = "main";
+    try {
+      const ref = gitExec(projectDir, ["symbolic-ref", "refs/remotes/origin/HEAD"]);
+      defaultBranch = ref.replace("refs/remotes/origin/", "");
+    } catch {
+      try {
+        gitExec(projectDir, ["rev-parse", "--verify", "refs/heads/main"]);
+        defaultBranch = "main";
+      } catch {
+        try {
+          gitExec(projectDir, ["rev-parse", "--verify", "refs/heads/master"]);
+          defaultBranch = "master";
+        } catch {
+          return listRecentCommits(projectDir, maxCount);
+        }
+      }
+    }
+    if (currentBranch === defaultBranch) {
+      return listRecentCommits(projectDir, maxCount);
+    }
+    const raw = gitExec(projectDir, [
+      "rev-list",
+      "--reverse",
+      `--max-count=${maxCount}`,
+      "HEAD",
+      "--not",
+      defaultBranch
+    ]);
+    return raw ? raw.split("\n").filter(Boolean) : [];
+  } catch {
+    return listRecentCommits(projectDir, maxCount);
+  }
+}
 function readFromBranch(projectDir, filePath, branchName) {
   branchName ??= getHistoryBranch();
   validateBranchPath(filePath);
@@ -1575,6 +1616,7 @@ export {
   getCurrentHead,
   listCommitsBetween,
   listRecentCommits,
+  listBranchOnlyCommits,
   readFromBranch,
   listBranchDir,
   getWorktreeId,

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

@@ -1,6 +1,15 @@
 import {
-  createEmbedder
-} from "./chunk-DBMUNBNB.js";
+  createEmbedder,
+  loadCodemapIgnore,
+  matchesDenyPattern
+} from "./chunk-5J6NLQUN.js";
+import {
+  commitInWorktree,
+  copyAndStage,
+  historyBranchExists,
+  withWorktree,
+  writeAndStage
+} from "./chunk-JGBXM5NC.js";
 import {
   readEvents
 } from "./chunk-YM2HV4IA.js";
@@ -46,6 +55,8 @@ import { execFileSync as execFileSync2 } from "child_process";
 import * as fs9 from "fs";
 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";
 var DEFAULT_MEMORY_CONFIG = MemoryConfigSchema.parse({});
 function loadMemoryConfig(projectDir) {
   const configPath = memoryConfigFile(projectDir);
@@ -248,9 +259,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(
@@ -406,11 +415,16 @@ var TRIVIAL_COMMANDS = /* @__PURE__ */ new Set([
   "date",
   "wc"
 ]);
-function filterSignificantEvents(events) {
+function filterSignificantEvents(events, projectDir) {
+  const ignorePatterns = projectDir ? loadCodemapIgnore(projectDir) : [];
   return events.filter((ev) => {
     if (ev.event === "tool_blocked" || ev.event === "permission_denied" || ev.event === "postcondition_failed") {
       return true;
     }
+    if (ev.filePath && ignorePatterns.length > 0 && projectDir) {
+      const rel = ev.filePath.startsWith(projectDir) ? ev.filePath.slice(projectDir.length + 1) : ev.filePath;
+      if (matchesDenyPattern(rel, ignorePatterns)) return false;
+    }
     if (ev.event === "tool_used" && ev.toolName === "Read") {
       return false;
     }
@@ -550,6 +564,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 +577,8 @@ function invokeClassifier(prompt, model, timeout) {
       "--permission-mode",
       "bypassPermissions"
     ], {
-      stdio: ["pipe", "pipe", "pipe"]
+      stdio: ["pipe", "pipe", "pipe"],
+      env
     });
     let stdout = "";
     let stderr = "";
@@ -1023,7 +1040,7 @@ async function classifySession(projectDir, sessionId, onProgress) {
     };
   }
   const unprocessedEvents = allEvents.slice(startIdx);
-  const filteredEvents = config.classifier.filterNoiseEvents ? filterSignificantEvents(unprocessedEvents) : unprocessedEvents;
+  const filteredEvents = config.classifier.filterNoiseEvents ? filterSignificantEvents(unprocessedEvents, projectDir) : unprocessedEvents;
   const meta = loadSessionMeta(projectDir, sessionId);
   if (!isSessionSignificant(meta, filteredEvents, config.classifier.minSignificantEvents)) {
     saveWatermark(projectDir, {
@@ -1324,17 +1341,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,113 +1392,238 @@ 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 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++;
+    }
+    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
   };
-  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 {
+}
+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++;
     }
-    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 {
+  }
+  return { fileCount, totalBytes };
+}
+async function importMemories(projectDir) {
+  const branchName = getMemoryBranch();
+  if (!memoryBranchExists(projectDir)) {
+    return { success: false, memoriesImported: 0, filesImported: 0, totalSizeBytes: 0, message: "Memory branch does not exist" };
+  }
+  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++;
+          }
+        }
       }
     }
+    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 };
 }
-function importMemories(projectDir) {
-  const branch = getMemoryBranch();
-  if (!memoryBranchExists(projectDir)) {
-    return { success: false, memoriesImported: 0, message: "Memory branch does not exist" };
+function progressFile(projectDir) {
+  return join8(projectMemoryDir(projectDir), "classify-progress.json");
+}
+var STALE_THRESHOLD_MS = 2 * 60 * 1e3;
+function writeClassifyBatchProgress(projectDir, progress) {
+  try {
+    const p = { ...progress, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+    writeFileSync8(progressFile(projectDir), JSON.stringify(p, null, 2));
+  } catch {
   }
+}
+function readClassifyBatchProgress(projectDir) {
+  const file = progressFile(projectDir);
+  if (!existsSync10(file)) return null;
   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 raw = readFileSync8(file, "utf-8");
+    const data = JSON.parse(raw);
+    if (data.status === "classifying" && data.updatedAt) {
+      const age = Date.now() - new Date(data.updatedAt).getTime();
+      if (age > STALE_THRESHOLD_MS) {
+        return {
+          ...data,
+          status: "error",
+          error: "Classification process appears to have stopped unexpectedly."
+        };
       }
     }
-    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 };
+    return data;
+  } catch {
+    return null;
+  }
+}
+function clearClassifyBatchProgress(projectDir) {
+  try {
+    const file = progressFile(projectDir);
+    if (existsSync10(file)) unlinkSync3(file);
+  } catch {
   }
 }
 
@@ -1542,5 +1674,8 @@ export {
   memoryBranchExists,
   initMemoryBranch,
   exportMemories,
-  importMemories
+  importMemories,
+  writeClassifyBatchProgress,
+  readClassifyBatchProgress,
+  clearClassifyBatchProgress
 };