@ulpi/cli 0.1.2 → 0.1.3

package/dist/auth-KQCJ43U2.js

@@ -0,0 +1,118 @@
+import {
+  extractCredentials,
+  getCredentialExpiry,
+  validateCredentials
+} from "./chunk-G6SVZ4Q5.js";
+import "./chunk-4VNS5WPM.js";
+
+// src/commands/auth.ts
+import * as fs from "fs";
+import chalk from "chalk";
+async function runAuth(args) {
+  const subcommand = args[0];
+  switch (subcommand) {
+    case "setup":
+      return authSetup();
+    case "check":
+      return authCheck(args.slice(1));
+    case "refresh":
+      return authSetup();
+    // Same flow as setup
+    default:
+      console.log(`
+${chalk.bold("ulpi auth")} \u2014 Manage Claude Code credentials for CI workers
+
+Usage: ulpi auth <command>
+
+Commands:
+  setup     Extract Claude Code credentials for CI use (interactive)
+  check     Validate stored credentials
+  refresh   Re-authenticate and output new credentials
+
+How it works:
+  1. Run 'ulpi auth setup' on a machine with a browser
+  2. It extracts your Claude Code session credentials
+  3. Outputs a base64 blob you can store as a Docker secret
+  4. Set ULPI_CLAUDE_CREDENTIALS in your orchestrator config
+`.trim());
+  }
+}
+async function authSetup() {
+  console.log(chalk.blue("Extracting Claude Code credentials..."));
+  console.log();
+  const claudeDir = process.env.CLAUDE_CONFIG_DIR ?? `${process.env.HOME}/.claude`;
+  if (!fs.existsSync(claudeDir)) {
+    console.log(chalk.yellow("No Claude Code configuration found."));
+    console.log();
+    console.log("Please run 'claude login' first to authenticate with Anthropic.");
+    console.log("Then run 'ulpi auth setup' again.");
+    process.exit(1);
+  }
+  try {
+    const blob = extractCredentials(claudeDir);
+    const expiry = getCredentialExpiry(blob);
+    console.log(chalk.green("Credentials extracted successfully."));
+    console.log();
+    if (expiry) {
+      console.log(`  Expires: ${expiry}`);
+      console.log();
+    }
+    console.log(chalk.bold("Your credentials blob:"));
+    console.log();
+    console.log(blob);
+    console.log();
+    console.log(chalk.bold("To use in your orchestrator:"));
+    console.log();
+    console.log("  1. Set as environment variable:");
+    console.log(chalk.cyan(`     export ULPI_CLAUDE_CREDENTIALS="${blob.slice(0, 20)}..."`));
+    console.log();
+    console.log("  2. Or add to docker-compose.yml:");
+    console.log(chalk.cyan("     environment:"));
+    console.log(chalk.cyan("       - ULPI_CLAUDE_CREDENTIALS=${ULPI_CLAUDE_CREDENTIALS}"));
+    console.log();
+    console.log("  3. Or store as a Docker secret:");
+    console.log(chalk.cyan(`     echo "${blob.slice(0, 20)}..." | docker secret create ulpi-claude-creds -`));
+    console.log();
+    console.log(chalk.yellow("Keep this blob safe \u2014 it contains your Claude Code session credentials."));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    console.error(chalk.red(`Error: ${message}`));
+    process.exit(1);
+  }
+}
+async function authCheck(args) {
+  const blob = args[0] ?? process.env.ULPI_CLAUDE_CREDENTIALS;
+  if (!blob) {
+    console.error(chalk.red("Error: No credentials provided."));
+    console.log("  Provide as argument: ulpi auth check <blob>");
+    console.log("  Or set ULPI_CLAUDE_CREDENTIALS env var");
+    process.exit(1);
+  }
+  console.log(chalk.blue("Validating credentials..."));
+  const valid = validateCredentials(blob);
+  const expiry = getCredentialExpiry(blob);
+  if (valid) {
+    console.log(chalk.green("Credentials are valid."));
+    if (expiry) {
+      const expiryDate = new Date(expiry);
+      const now = /* @__PURE__ */ new Date();
+      const hoursLeft = (expiryDate.getTime() - now.getTime()) / (60 * 60 * 1e3);
+      if (hoursLeft < 0) {
+        console.log(chalk.red(`  Expired: ${expiry}`));
+        console.log(chalk.yellow("  Run 'ulpi auth refresh' to re-authenticate."));
+      } else if (hoursLeft < 24) {
+        console.log(chalk.yellow(`  Expires soon: ${expiry} (${Math.floor(hoursLeft)}h remaining)`));
+        console.log(chalk.yellow("  Consider running 'ulpi auth refresh' soon."));
+      } else {
+        console.log(chalk.green(`  Expires: ${expiry}`));
+      }
+    }
+  } else {
+    console.log(chalk.red("Credentials are invalid or corrupted."));
+    console.log("Run 'ulpi auth setup' to generate new credentials.");
+    process.exit(1);
+  }
+}
+export {
+  runAuth
+};

package/dist/{chunk-UA6EFK64.js → chunk-2VYFVYJL.js}

@@ -49,7 +49,7 @@ import {
   updateEntryEnrichment,
   withWorktree,
   writeAndStage
-} from "./chunk-NNUWU6CV.js";
+} from "./chunk-JGBXM5NC.js";
 import {
   JsonSessionStore,
   readEvents
@@ -74,7 +74,7 @@ import {
   saveUlpiSettings
 } from "./chunk-7LXY5UVC.js";
 
-// ../api/dist/chunk-77FAT4LI.js
+// ../api/dist/chunk-P4BERD2G.js
 import * as http from "http";
 import * as fs12 from "fs";
 import * as path9 from "path";
@@ -394,33 +394,51 @@ async function putUsernameSettings(ctx) {
     resolvedHistoryBranch: getHistoryBranch()
   }, 200, ctx.req);
 }
+function yamlEscapeString(s) {
+  return s.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
 function writeYamlFields(obj, lines, indent) {
   const pad = " ".repeat(indent);
   for (const [k, v] of Object.entries(obj)) {
     if (k === "id" || k === "type" || k === "source") continue;
     if (typeof v === "string") {
-      lines.push(`${pad}${k}: "${v}"`);
+      lines.push(`${pad}${k}: "${yamlEscapeString(v)}"`);
     } else if (typeof v === "boolean" || typeof v === "number") {
       lines.push(`${pad}${k}: ${v}`);
     } else if (Array.isArray(v)) {
       lines.push(`${pad}${k}:`);
       for (const item of v) {
         if (typeof item === "string") {
-          lines.push(`${pad}  - "${item}"`);
+          lines.push(`${pad}  - "${yamlEscapeString(item)}"`);
+        } else if (item && typeof item === "object") {
+          const entries = Object.entries(item);
+          if (entries.length > 0) {
+            const [firstKey, firstVal] = entries[0];
+            lines.push(`${pad}  - ${firstKey}: ${formatScalar(firstVal)}`);
+            for (let i = 1; i < entries.length; i++) {
+              const [ek, ev] = entries[i];
+              lines.push(`${pad}    ${ek}: ${formatScalar(ev)}`);
+            }
+          }
         }
       }
     }
   }
 }
+function formatScalar(v) {
+  if (typeof v === "string") return `"${yamlEscapeString(v)}"`;
+  if (typeof v === "boolean" || typeof v === "number") return String(v);
+  return `"${String(v)}"`;
+}
 function writeRulesConfig(rulesPath, config) {
   const lines = [
     "# ULPI \u2014 Rules Configuration",
     "# Generated via Web UI",
     "",
     "project:",
-    `  name: "${config.project.name}"`,
-    `  runtime: "${config.project.runtime}"`,
-    `  package_manager: "${config.project.package_manager}"`,
+    `  name: "${yamlEscapeString(config.project.name)}"`,
+    `  runtime: "${yamlEscapeString(config.project.runtime)}"`,
+    `  package_manager: "${yamlEscapeString(config.project.package_manager)}"`,
     ""
   ];
   const sections = [
@@ -2245,7 +2263,7 @@ async function exportObsidian(ctx) {
   jsonResponse(ctx.res, { format: "obsidian", content: md }, 200, ctx.req);
 }
 async function getEngine() {
-  return await import("./dist-MFFX7TZW.js");
+  return await import("./dist-CB5D5LMO.js");
 }
 var runningPipelines = /* @__PURE__ */ new Map();
 var activeWatchers = /* @__PURE__ */ new Map();
@@ -2551,7 +2569,7 @@ async function codemapActionHandler(ctx) {
   }
 }
 async function getEngine2() {
-  return await import("./dist-57UMTPGR.js");
+  return await import("./dist-GJYT2OQV.js");
 }
 async function memoryStatusHandler(ctx) {
   try {
@@ -2559,7 +2577,8 @@ async function memoryStatusHandler(ctx) {
     const stats = await engine.getMemoryStats(ctx.projectDir);
     const config = engine.loadMemoryConfig(ctx.projectDir);
     const initialized = engine.isMemoryInitialized(ctx.projectDir);
-    jsonResponse(ctx.res, { stats, config, initialized }, 200, ctx.req);
+    const classifyProgress = engine.readClassifyBatchProgress(ctx.projectDir);
+    jsonResponse(ctx.res, { stats, config, initialized, classifyProgress }, 200, ctx.req);
   } catch (err) {
     const message = err instanceof Error ? err.message : "Failed to get memory status";
     jsonResponse(ctx.res, { error: message }, 500, ctx.req);
@@ -2739,7 +2758,7 @@ async function memoryActionHandler(ctx) {
     return;
   }
   const action = data.action;
-  const validActions = ["init", "export", "import", "enable", "disable", "classify", "reindex"];
+  const validActions = ["init", "export", "import", "enable", "disable", "classify", "classify-all", "classify-clear", "reindex"];
   if (!validActions.includes(action)) {
     jsonResponse(
       ctx.res,
@@ -2796,6 +2815,32 @@ async function memoryActionHandler(ctx) {
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
         return;
       }
+      case "classify-all": {
+        const { spawn: spawn4 } = await import("child_process");
+        const ulpiBin = process.argv[1];
+        const args = ["memory", "classify", "-p", ctx.projectDir];
+        if (typeof data.branch === "string" && data.branch) {
+          args.push("--branch", data.branch);
+        }
+        if (data.export) args.push("--export");
+        const child = spawn4(process.execPath, [ulpiBin, ...args], {
+          detached: true,
+          stdio: "ignore",
+          env: { ...process.env, ULPI_BG_CLASSIFY: "1" }
+        });
+        child.unref();
+        jsonResponse(ctx.res, {
+          ok: true,
+          action,
+          message: "Classification started"
+        }, 200, ctx.req);
+        return;
+      }
+      case "classify-clear": {
+        engine.clearClassifyBatchProgress(ctx.projectDir);
+        jsonResponse(ctx.res, { ok: true, action, message: "Classification progress cleared" }, 200, ctx.req);
+        return;
+      }
       case "reindex": {
         const result = await engine.reindexMemories(ctx.projectDir);
         jsonResponse(ctx.res, { ok: true, action, ...result }, 200, ctx.req);
@@ -3457,7 +3502,7 @@ async function historyInitHandler(ctx) {
     }
     let gitHooksResult = { installed: [], skipped: [] };
     try {
-      const { installGitHooks } = await import("./dist-RJGCUS3L.js");
+      const { installGitHooks } = await import("./dist-QAU3LGJN.js");
       const binaryPath = getBinaryPath();
       gitHooksResult = installGitHooks(projectDir, binaryPath);
     } catch {
@@ -3495,8 +3540,10 @@ async function historyBackfillHandler(ctx) {
   } catch {
   }
   const limit = Math.min(options.limit ?? 20, 100);
+  const branchOnly = options.branchOnly ?? false;
   const {
     listRecentCommits,
+    listBranchOnlyCommits,
     getCommitMetadata,
     getCommitDiffStats,
     getCommitRawDiff,
@@ -3506,8 +3553,8 @@ async function historyBackfillHandler(ctx) {
     entryExists,
     writeHistoryEntry,
     DEFAULT_HISTORY_CONFIG
-  } = await import("./dist-RJGCUS3L.js");
-  const commits = listRecentCommits(projectDir, limit);
+  } = await import("./dist-QAU3LGJN.js");
+  const commits = branchOnly ? listBranchOnlyCommits(projectDir, limit) : listRecentCommits(projectDir, limit);
   if (commits.length === 0) {
     jsonResponse(res, { captured: 0, skipped: 0, total: 0 }, 200, req);
     return;
@@ -3830,7 +3877,7 @@ async function historyEntryTagsHandler(ctx) {
     return;
   }
   try {
-    const { updateEntryTags } = await import("./dist-RJGCUS3L.js");
+    const { updateEntryTags } = await import("./dist-QAU3LGJN.js");
     await updateEntryTags(projectDir, sha, payload.tags);
     jsonResponse(res, { success: true, sha, tags: payload.tags }, 200, req);
   } catch (err) {
@@ -3846,7 +3893,7 @@ async function historyEntryTranscriptHandler(ctx) {
     jsonResponse(res, { error: "History branch not initialized" }, 400, req);
     return;
   }
-  const { readEntryTranscript } = await import("./dist-RJGCUS3L.js");
+  const { readEntryTranscript } = await import("./dist-QAU3LGJN.js");
   const transcript = readEntryTranscript(projectDir, sha);
   if (!transcript) {
     jsonResponse(res, { error: "No transcript for this entry" }, 404, req);

package/dist/{chunk-VGZLMUNO.js → chunk-5J6NLQUN.js}

@@ -4,7 +4,7 @@ import {
   historyBranchExists,
   withWorktree,
   writeAndStage
-} from "./chunk-NNUWU6CV.js";
+} from "./chunk-JGBXM5NC.js";
 import {
   CodemapConfigSchema
 } from "./chunk-74WVVWJ4.js";

package/dist/{chunk-S253WCQJ.js → chunk-F7OXF7Z3.js}

@@ -13,7 +13,7 @@ var REGISTRY_URL = CLI_REGISTRY_URL;
 var FETCH_TIMEOUT_MS = 5e3;
 function getCurrentVersion() {
   try {
-    return "0.1.2";
+    return "0.1.3";
   } catch {
     return "0.0.0";
   }

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-FNPD3V2X.js → chunk-PDR55ZNW.js}

@@ -1,13 +1,15 @@
 import {
-  createEmbedder
-} from "./chunk-VGZLMUNO.js";
+  createEmbedder,
+  loadCodemapIgnore,
+  matchesDenyPattern
+} from "./chunk-5J6NLQUN.js";
 import {
   commitInWorktree,
   copyAndStage,
   historyBranchExists,
   withWorktree,
   writeAndStage
-} from "./chunk-NNUWU6CV.js";
+} from "./chunk-JGBXM5NC.js";
 import {
   readEvents
 } from "./chunk-YM2HV4IA.js";
@@ -53,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);
@@ -411,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;
     }
@@ -1031,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, {
@@ -1578,6 +1587,45 @@ function copyDirRecursiveImport(srcDir, destDir) {
   }
   return { fileCount, totalBytes };
 }
+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 = 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 data;
+  } catch {
+    return null;
+  }
+}
+function clearClassifyBatchProgress(projectDir) {
+  try {
+    const file = progressFile(projectDir);
+    if (existsSync10(file)) unlinkSync3(file);
+  } catch {
+  }
+}
 
 export {
   DEFAULT_MEMORY_CONFIG,
@@ -1626,5 +1674,8 @@ export {
   memoryBranchExists,
   initMemoryBranch,
   exportMemories,
-  importMemories
+  importMemories,
+  writeClassifyBatchProgress,
+  readClassifyBatchProgress,
+  clearClassifyBatchProgress
 };