@loops-adk/core 0.1.0 → 0.1.1

package/dist/{chunk-3BPU34DE.js → chunk-6BDWTFOS.js}

@@ -2,10 +2,11 @@ import { redactSecrets } from './chunk-JFTXJ7I2.js';
 import { isEngine } from './chunk-XC46B4FD.js';
 import { isLimitError, waitMsFor } from './chunk-Y2SD7GBL.js';
 import { LoopError } from './chunk-I3STY7U6.js';
-import { readFileSync, mkdtempSync, existsSync, writeFileSync, appendFileSync, mkdirSync, rmSync } from 'fs';
+import { readFileSync, mkdtempSync, existsSync, writeFileSync, appendFileSync, readdirSync, mkdirSync, rmSync } from 'fs';
 import { execa } from 'execa';
-import { tmpdir } from 'os';
+import { tmpdir, homedir } from 'os';
 import { join, dirname } from 'path';
+import { randomBytes } from 'crypto';
 
 // src/core/describe.ts
 var META = /* @__PURE__ */ new WeakMap();
@@ -1975,6 +1976,174 @@ var NOISE = /* @__PURE__ */ new Set([
   "engine:text",
   "engine:thinking"
 ]);
+function runsHome() {
+  const base = process.env.LOOPS_HOME ?? join(homedir(), ".loops");
+  return join(base, "runs");
+}
+function slug(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 32) || "run";
+}
+function newRunId(title) {
+  return `${slug(title)}-${randomBytes(3).toString("hex")}`;
+}
+function startSupervisor(input) {
+  const dir = join(runsHome(), input.runId);
+  mkdirSync(dir, { recursive: true });
+  const eventsPath = join(dir, "events.jsonl");
+  const statusPath = join(dir, "status.json");
+  try {
+    writeFileSync(eventsPath, "");
+  } catch {
+  }
+  const status = {
+    runId: input.runId,
+    pid: process.pid,
+    cwd: input.cwd,
+    title: input.title,
+    startedAt: Date.now(),
+    updatedAt: Date.now(),
+    status: "running",
+    shape: input.shape,
+    live: {
+      path: [],
+      iteration: 0,
+      usage: { inputTokens: 0, outputTokens: 0, calls: 0 }
+    }
+  };
+  const writeStatus = () => {
+    status.updatedAt = Date.now();
+    try {
+      writeFileSync(statusPath, JSON.stringify(status, null, 2));
+    } catch {
+    }
+  };
+  writeStatus();
+  const sink = (event) => {
+    if (!NOISE.has(event.kind)) {
+      try {
+        appendFileSync(eventsPath, `${JSON.stringify(event)}
+`);
+      } catch {
+      }
+    }
+    switch (event.kind) {
+      case "loop:iteration":
+        status.live.path = event.path;
+        status.live.iteration = event.iteration;
+        break;
+      case "loop:condition":
+        status.live.lastGate = {
+          which: event.which,
+          met: event.result.met,
+          confidence: event.result.confidence,
+          reason: event.result.reason
+        };
+        break;
+      case "dag:node":
+        status.live.path = [...event.path, event.node];
+        break;
+      case "loop:end":
+      case "dag:end":
+      case "job:end":
+        status.live.lastOutcome = {
+          status: event.outcome.status,
+          summary: event.outcome.summary
+        };
+        status.live.path = event.path;
+        break;
+      case "engine:usage":
+        status.live.usage.inputTokens += event.usage.inputTokens;
+        status.live.usage.outputTokens += event.usage.outputTokens;
+        status.live.usage.calls += 1;
+        break;
+    }
+    if (!NOISE.has(event.kind)) writeStatus();
+  };
+  const finish = (outcome) => {
+    status.status = outcome.status;
+    status.endedAt = Date.now();
+    status.live.lastOutcome = {
+      status: outcome.status,
+      summary: outcome.summary
+    };
+    writeStatus();
+  };
+  return { runId: input.runId, dir, sink, finish };
+}
+function isAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (e) {
+    return e.code === "EPERM";
+  }
+}
+function readRunStatus(runId) {
+  try {
+    const raw = readFileSync(join(runsHome(), runId, "status.json"), "utf8");
+    const s = JSON.parse(raw);
+    s.alive = s.status === "running" ? isAlive(s.pid) : false;
+    return s;
+  } catch {
+    return void 0;
+  }
+}
+function listRuns() {
+  const base = runsHome();
+  if (!existsSync(base)) return [];
+  const out = [];
+  for (const id of readdirSync(base)) {
+    const s = readRunStatus(id);
+    if (s) out.push(s);
+  }
+  return out.sort((a, b) => b.startedAt - a.startedAt);
+}
+function runEventsPath(runId) {
+  return join(runsHome(), runId, "events.jsonl");
+}
+function formatEvent(event) {
+  const at = event.path.length ? `${event.path.join(" \u203A ")} ` : "";
+  switch (event.kind) {
+    case "loop:start":
+      return `${at}\u25B8 loop${event.max ? ` (max ${event.max})` : ""}`;
+    case "dag:start":
+      return `${at}\u25B8 dag (${event.nodes.length} nodes)`;
+    case "loop:iteration":
+      return `${at}\xB7 iteration ${event.iteration}`;
+    case "loop:condition":
+      return `${at}\xB7 ${event.which} ${event.result.met ? "met" : "not met"}: ${event.result.reason}`;
+    case "loop:review":
+      return `${at}\xB7 review: ${event.outcome.status}`;
+    case "loop:end":
+      return `${at}\u25C2 ${event.outcome.status} (${event.iterations} iter)`;
+    case "dag:node":
+      return `${at}\xB7 node ${event.node}: ${event.phase}${event.outcome ? ` (${event.outcome.status})` : ""}`;
+    case "dag:end":
+      return `${at}\u25C2 dag ${event.outcome.status}`;
+    case "job:start":
+      return `${at}\u2022 ${event.label}`;
+    case "job:end":
+      return `${at}\u2022 ${event.label}: ${event.outcome.status}`;
+    case "engine:tool":
+      return `${at}  tool ${event.name} ${event.phase}`;
+    case "engine:usage":
+      return `${at}  ${event.model}: ${event.usage.inputTokens}/${event.usage.outputTokens} tok`;
+    case "limit:wait":
+      return `${at}\u23F8 limit ${event.code}: waiting ${Math.round(event.waitMs / 1e3)}s`;
+    case "limit:pause":
+      return `${at}\u23F8 paused (${event.code}): ${event.reason}`;
+    case "log":
+      return `${at}${event.message}`;
+    case "error":
+      return `${at}\u2717 ${event.code}: ${event.message}`;
+    default:
+      return `${at}${event.kind}`;
+  }
+}
+var NOISE2 = /* @__PURE__ */ new Set([
+  "engine:text",
+  "engine:thinking"
+]);
 var CHECKPOINT_AT = /* @__PURE__ */ new Set([
   "loop:iteration",
   "loop:end",
@@ -1989,7 +2158,7 @@ function makeRecorder(path) {
   ensureDir2(path);
   writeFileSync(path, "");
   return (event) => {
-    if (NOISE.has(event.kind)) return;
+    if (NOISE2.has(event.kind)) return;
     try {
       appendFileSync(path, `${JSON.stringify(event)}
 `);
@@ -2051,10 +2220,23 @@ async function run(job, options = {}) {
       });
     }
   }
+  const dir = options.cwd ?? process.cwd();
   const sinks = [];
   if (options.recordTo) sinks.push(makeRecorder(options.recordTo));
   if (options.checkpoint)
     sinks.push(makeCheckpointer(options.checkpoint, initialState));
+  let supervisor;
+  if (options.supervise) {
+    const shape = jobMeta(job);
+    const title = shape?.name ?? "run";
+    supervisor = startSupervisor({
+      runId: newRunId(title),
+      cwd: dir,
+      title,
+      shape
+    });
+    sinks.push(supervisor.sink);
+  }
   const emit = (event) => {
     stats.record(event);
     if (budget && event.kind === "engine:usage")
@@ -2063,7 +2245,6 @@ async function run(job, options = {}) {
     for (const sink of sinks) sink(event);
   };
   const resolveEngine = (ref) => registry.create(ref, defaultEngine);
-  const dir = options.cwd ?? process.cwd();
   const workspace = {
     dir,
     branch: await currentBranch({ cwd: dir, signal: controller.signal })
@@ -2081,18 +2262,21 @@ async function run(job, options = {}) {
         message: `environment "${options.environment.name}" failed to start: ${error.message}`,
         code: error.code
       });
+      const failOutcome = {
+        status: "fail",
+        summary: `environment failed to start: ${error.message}`,
+        error
+      };
+      supervisor?.finish(failOutcome);
       return {
-        outcome: {
-          status: "fail",
-          summary: `environment failed to start: ${error.message}`,
-          error
-        },
+        outcome: failOutcome,
         stats: stats.snapshot(),
         budget: budget ? {
           limit: budget.limit,
           spent: budget.spent(),
           remaining: budget.remaining()
-        } : void 0
+        } : void 0,
+        runId: supervisor?.runId
       };
     }
   }
@@ -2133,6 +2317,7 @@ async function run(job, options = {}) {
   }
   if (outcome.status === "paused" && options.checkpoint)
     flushCheckpoint(options.checkpoint, initialState);
+  supervisor?.finish(outcome);
   return {
     outcome,
     stats: stats.snapshot(),
@@ -2140,7 +2325,8 @@ async function run(job, options = {}) {
       limit: budget.limit,
       spent: budget.spent(),
       remaining: budget.remaining()
-    } : void 0
+    } : void 0,
+    runId: supervisor?.runId
   };
 }
 function exitCodeFor(outcome) {
@@ -2158,6 +2344,6 @@ function exitCodeFor(outcome) {
   }
 }
 
-export { Budget, EXIT_PAUSED, EngineRegistry, GhForge, MockForge, Stats, addWorktree, agentCheck, agentJob, all, always, any, appendLedger, appendPrompt, bodyPassed, buildChecksArgs, buildCreateArgs, buildEditArgs, buildMergeArgs, buildViewArgs, childContext, commandSucceeds, commit, commitJob, compactLedger, composeCommitBody, conflictedFiles, consolidate, consolidateJob, currentBranch, defineAgent, defineSkill, deleteBranch, describeConditions, ensureIgnored, exitCodeFor, fnJob, forgeChecks, fromFile, gateJob, groundingText, hasStagedChanges, headSha, isDirty, isForge, isRepo, jobMeta, kickback, ledgerPath, log, loop, mergeAbort, mergeBranch, mergeNoCommit, minConfidence, never, not, predicate, promptPath, push, quorum, readLedger, readPrompt, removeWorktree, renderPlan, resetLedger, resetPrompt, resolveSystem, retrieveLedger, run, setMeta, stageAll, toCondition };
-//# sourceMappingURL=chunk-3BPU34DE.js.map
-//# sourceMappingURL=chunk-3BPU34DE.js.map
+export { Budget, EXIT_PAUSED, EngineRegistry, GhForge, MockForge, Stats, addWorktree, agentCheck, agentJob, all, always, any, appendLedger, appendPrompt, bodyPassed, buildChecksArgs, buildCreateArgs, buildEditArgs, buildMergeArgs, buildViewArgs, childContext, commandSucceeds, commit, commitJob, compactLedger, composeCommitBody, conflictedFiles, consolidate, consolidateJob, currentBranch, defineAgent, defineSkill, deleteBranch, describeConditions, ensureIgnored, exitCodeFor, fnJob, forgeChecks, formatEvent, fromFile, gateJob, groundingText, hasStagedChanges, headSha, isDirty, isForge, isRepo, jobMeta, kickback, ledgerPath, listRuns, log, loop, mergeAbort, mergeBranch, mergeNoCommit, minConfidence, never, not, predicate, promptPath, push, quorum, readLedger, readPrompt, readRunStatus, removeWorktree, renderPlan, resetLedger, resetPrompt, resolveSystem, retrieveLedger, run, runEventsPath, runsHome, setMeta, stageAll, toCondition };
+//# sourceMappingURL=chunk-6BDWTFOS.js.map
+//# sourceMappingURL=chunk-6BDWTFOS.js.map