@ulpi/cli 0.1.5 → 0.1.6

package/dist/{chunk-L3PWNHSA.js → chunk-3WB5CXH4.js}

@@ -1,7 +1,7 @@
 import {
   JsonSessionStore,
   readEvents
-} from "./chunk-26LLDX2T.js";
+} from "./chunk-SEU7WWNQ.js";
 import {
   DEFAULT_AI_MODEL,
   REVIEWS_DIR,
@@ -9,7 +9,7 @@ import {
   getHistoryBranch,
   projectGuardsFile,
   projectGuardsFileAlt
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
 // ../../packages/history-engine/dist/index.js
 import { execFileSync } from "child_process";
@@ -1591,10 +1591,9 @@ fi
 ${HOOK_MARKER_END}`;
 }
 function generatePostCommit(binaryPath) {
-  const cmd = binaryPath.includes(" ") ? binaryPath : `"${binaryPath}"`;
   return `${HOOK_MARKER_START}
 # Trigger on-commit history capture (fail-open)
-${cmd} history capture HEAD 2>/dev/null || true
+"${binaryPath}" history capture HEAD 2>/dev/null || true
 ${HOOK_MARKER_END}`;
 }
 function generatePrePush() {
@@ -1606,6 +1605,177 @@ if git rev-parse --verify ulpi/history >/dev/null 2>&1; then
 fi
 ${HOOK_MARKER_END}`;
 }
+async function writeIterationEntry(projectDir, sessionId, iteration, branchName) {
+  branchName ??= getHistoryBranch();
+  if (!historyBranchExists(projectDir, branchName)) return;
+  const entry = {
+    iterationId: iteration.id,
+    sessionId,
+    taskId: iteration.taskId,
+    agentType: iteration.agentType,
+    agentModel: iteration.agentModel,
+    duration: iteration.duration,
+    outputSummary: iteration.outputSummary,
+    filesChanged: iteration.filesChanged ?? [],
+    commitSha: iteration.commitSha,
+    status: mapStatus(iteration.status),
+    tokenUsage: iteration.tokenUsage,
+    startedAt: iteration.startedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: iteration.completedAt,
+    error: iteration.error,
+    projectDir,
+    capturedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  await withWorktree(projectDir, branchName, (worktreeDir) => {
+    const iterPath = `iterations/${sessionId}/${iteration.id}.json`;
+    writeAndStage(worktreeDir, iterPath, JSON.stringify(entry, null, 2));
+    updateTaskIndex(worktreeDir, projectDir, entry, branchName);
+    commitInWorktree(
+      worktreeDir,
+      `chore(history): iteration ${iteration.id} for task ${iteration.taskId}`
+    );
+  });
+}
+function readIterationsForSession(projectDir, sessionId, branchName) {
+  branchName ??= getHistoryBranch();
+  if (!historyBranchExists(projectDir, branchName)) return [];
+  const dir = `iterations/${sessionId}`;
+  const files = listBranchDir(projectDir, dir, branchName);
+  const entries = [];
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+    const raw = readFromBranch(projectDir, `${dir}/${file}`, branchName);
+    if (!raw) continue;
+    try {
+      entries.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  entries.sort(
+    (a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime()
+  );
+  return entries;
+}
+function readIterationsForTask(projectDir, taskId, branchName) {
+  branchName ??= getHistoryBranch();
+  if (!historyBranchExists(projectDir, branchName)) return [];
+  const indexRaw = readFromBranch(
+    projectDir,
+    `iterations/tasks/${taskId}.json`,
+    branchName
+  );
+  if (!indexRaw) return [];
+  let index;
+  try {
+    index = JSON.parse(indexRaw);
+  } catch {
+    return [];
+  }
+  const entries = [];
+  for (let i = 0; i < index.sessionIds.length; i++) {
+    const sessionId = index.sessionIds[i];
+    const iterationId = index.iterationIds[i];
+    if (!sessionId || !iterationId) continue;
+    const raw = readFromBranch(
+      projectDir,
+      `iterations/${sessionId}/${iterationId}.json`,
+      branchName
+    );
+    if (!raw) continue;
+    try {
+      entries.push(JSON.parse(raw));
+    } catch {
+    }
+  }
+  entries.sort(
+    (a, b) => new Date(a.startedAt).getTime() - new Date(b.startedAt).getTime()
+  );
+  return entries;
+}
+function linkTaskAcrossSessions(projectDir, taskId, branchName) {
+  branchName ??= getHistoryBranch();
+  if (!historyBranchExists(projectDir, branchName)) return null;
+  const raw = readFromBranch(
+    projectDir,
+    `iterations/tasks/${taskId}.json`,
+    branchName
+  );
+  if (!raw) return null;
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function getTaskHistory(projectDir, taskId, branchName) {
+  branchName ??= getHistoryBranch();
+  const iterations = readIterationsForTask(projectDir, taskId, branchName);
+  const sessions = [...new Set(iterations.map((it) => it.sessionId))];
+  return {
+    taskId,
+    totalIterations: iterations.length,
+    sessions,
+    iterations
+  };
+}
+function mapStatus(status) {
+  switch (status) {
+    case "completed":
+      return "completed";
+    case "failed":
+      return "failed";
+    case "skipped":
+      return "skipped";
+    default:
+      return "failed";
+  }
+}
+function updateTaskIndex(worktreeDir, projectDir, entry, branchName) {
+  const indexPath = `iterations/tasks/${entry.taskId}.json`;
+  let index;
+  const existingRaw = readFromBranch(projectDir, indexPath, branchName);
+  if (existingRaw) {
+    try {
+      index = JSON.parse(existingRaw);
+    } catch {
+      index = createEmptyIndex(entry.taskId);
+    }
+  } else {
+    index = createEmptyIndex(entry.taskId);
+  }
+  if (!index.iterationIds.includes(entry.iterationId)) {
+    index.iterationIds.push(entry.iterationId);
+    if (!index.sessionIds.includes(entry.sessionId)) {
+      index.sessionIds.push(entry.sessionId);
+    }
+    const sessionMap = /* @__PURE__ */ new Map();
+    for (let i = 0; i < index.iterationIds.length - 1; i++) {
+      const itId = index.iterationIds[i];
+      if (i < index.sessionIds.length) {
+        sessionMap.set(itId, index.sessionIds[i]);
+      }
+    }
+    sessionMap.set(entry.iterationId, entry.sessionId);
+    const iterationIds = [];
+    const sessionIds = [];
+    for (const itId of index.iterationIds) {
+      iterationIds.push(itId);
+      sessionIds.push(sessionMap.get(itId) ?? entry.sessionId);
+    }
+    index.iterationIds = iterationIds;
+    index.sessionIds = sessionIds;
+  }
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  writeAndStage(worktreeDir, indexPath, JSON.stringify(index, null, 2));
+}
+function createEmptyIndex(taskId) {
+  return {
+    taskId,
+    sessionIds: [],
+    iterationIds: [],
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
 
 export {
   historyBranchExists,
@@ -1648,5 +1818,10 @@ export {
   readTranscript,
   getTranscriptSize,
   installGitHooks,
-  uninstallGitHooks
+  uninstallGitHooks,
+  writeIterationEntry,
+  readIterationsForSession,
+  readIterationsForTask,
+  linkTaskAcrossSessions,
+  getTaskHistory
 };

package/dist/{chunk-K4OVPFY2.js → chunk-4UCJIAOU.js}

@@ -1,8 +1,8 @@
 import {
   resolveApiKey
-} from "./chunk-DDRLI6JU.js";
+} from "./chunk-C7CLUQI6.js";
 
-// ../../packages/codemap-engine/dist/chunk-ZW4DV263.js
+// ../../packages/embed-engine/dist/chunk-ZW4DV263.js
 var OPENAI_EMBEDDINGS_URL = "https://api.openai.com/v1/embeddings";
 var MAX_RETRIES = 3;
 var RETRY_BASE_MS = 1e3;

package/dist/chunk-4XTHZVDS.js

@@ -0,0 +1,109 @@
+import {
+  ULPI_GLOBAL_DIR
+} from "./chunk-C7CLUQI6.js";
+
+// ../api/dist/chunk-AZQGVTXK.js
+import * as fs from "fs";
+import * as path from "path";
+var JOBS_DIR = path.join(ULPI_GLOBAL_DIR, "jobs");
+function ensureJobsDir() {
+  if (!fs.existsSync(JOBS_DIR)) {
+    fs.mkdirSync(JOBS_DIR, { recursive: true });
+  }
+}
+function saveJob(job) {
+  ensureJobsDir();
+  const filePath = path.join(JOBS_DIR, `${job.id}.json`);
+  fs.writeFileSync(filePath, JSON.stringify(job, null, 2), "utf-8");
+}
+function loadJob(jobId) {
+  const filePath = path.join(JOBS_DIR, `${jobId}.json`);
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function listJobs() {
+  ensureJobsDir();
+  try {
+    const files = fs.readdirSync(JOBS_DIR).filter((f) => f.endsWith(".json"));
+    const jobs = [];
+    for (const file of files) {
+      try {
+        const content = fs.readFileSync(path.join(JOBS_DIR, file), "utf-8");
+        jobs.push(JSON.parse(content));
+      } catch {
+      }
+    }
+    jobs.sort(
+      (a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+    );
+    return jobs;
+  } catch {
+    return [];
+  }
+}
+function appendJobLog(job, level, message) {
+  if (!job.logs) job.logs = [];
+  job.logs.push({
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    level,
+    message
+  });
+}
+function deleteJob(jobId) {
+  const filePath = path.join(JOBS_DIR, `${jobId}.json`);
+  const eventsPath = path.join(JOBS_DIR, `${jobId}.events.jsonl`);
+  try {
+    fs.unlinkSync(filePath);
+  } catch {
+  }
+  try {
+    fs.unlinkSync(eventsPath);
+  } catch {
+  }
+  return true;
+}
+function appendEventLog(jobId, event) {
+  ensureJobsDir();
+  const filePath = path.join(JOBS_DIR, `${jobId}.events.jsonl`);
+  try {
+    fs.appendFileSync(filePath, JSON.stringify(event) + "\n", "utf-8");
+  } catch {
+  }
+}
+function readEventLogs(jobId) {
+  const filePath = path.join(JOBS_DIR, `${jobId}.events.jsonl`);
+  try {
+    const content = fs.readFileSync(filePath, "utf-8");
+    const events = [];
+    for (const line of content.split("\n")) {
+      if (!line.trim()) continue;
+      try {
+        events.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return events;
+  } catch {
+    return [];
+  }
+}
+function generateJobId() {
+  return `job-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+var activeJobs = /* @__PURE__ */ new Map();
+
+export {
+  saveJob,
+  loadJob,
+  listJobs,
+  appendJobLog,
+  deleteJob,
+  appendEventLog,
+  readEventLogs,
+  generateJobId,
+  activeJobs
+};