@outerlayer/cli 0.8.0 → 0.8.2

package/dist/{chunk-7ZR5UPMB.js → chunk-CMFCCIQN.js}

@@ -8524,5 +8524,171 @@ function parsePolicy(policyFile, validatorFiles) {
   );
   return { levels, customs, mergeGate, review, testProof, criteriaMissing, problems };
 }
+function extractCommandText(raw) {
+  const text = raw.trim();
+  if (!text) return null;
+  if (text.startsWith("{") || text.startsWith("[")) {
+    try {
+      const parsed = JSON.parse(text);
+      if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
+        const command = parsed["command"];
+        return typeof command === "string" && command.trim() ? command.trim() : null;
+      }
+      return null;
+    } catch {
+      return null;
+    }
+  }
+  return text;
+}
+function normalizeCommand(command) {
+  let out = command.trim().replace(/\s+/g, " ");
+  for (; ; ) {
+    const next = out.replace(/^cd\s+[^&;|]+(?:&&|;)\s*/, "");
+    if (next === out) break;
+    out = next.trim();
+  }
+  out = out.replace(/^(?:[A-Z_][A-Z0-9_]*=\S+\s+)+/, "");
+  out = out.replace(/^(?:npx|bunx)\s+(?:--yes\s+|-y\s+)?/, "");
+  out = out.replace(/^(?:yarn|pnpm)\s+(?:run\s+)?/, "");
+  return out.trim();
+}
+var KIND_RULES = [
+  { kind: "migration", pattern: /\bsupabase\s+(?:migration|db)\b/ },
+  { kind: "vcs", pattern: /^git\s|\bgh\s+(?:pr|api|issue)\b/ },
+  { kind: "test", pattern: /^(?:vitest|jest|playwright)\b/ },
+  { kind: "test", pattern: /^(?:ci:unit|test(?::\w+)?)\b/ },
+  { kind: "test", pattern: /^turbo\s+run\s+test\b/ },
+  { kind: "lint", pattern: /^(?:eslint|ci:lint|lint(?::\w+)?|knip|prettier)\b/ },
+  { kind: "build", pattern: /^(?:tsc|turbo\s+run\s+build|build(?::\w+)?|next\s+build)\b/ }
+];
+function classifyCommand(rawCommand) {
+  const normalized = normalizeCommand(rawCommand);
+  let kind = "other";
+  for (const rule of KIND_RULES) {
+    if (rule.pattern.test(normalized)) {
+      kind = rule.kind;
+      break;
+    }
+  }
+  return { normalized, kind };
+}
+function splitCommandSegments(rawCommand) {
+  const noHeredocs = rawCommand.replace(/<<-?\s*'?([A-Za-z_][A-Za-z0-9_]*)'?[\s\S]*?\n\1\b/g, "");
+  return noHeredocs.split(/&&|;|\n/).map((segment) => segment.trim()).filter((segment) => segment.length > 0);
+}
+function extractFacts(spans) {
+  const runs = [];
+  const edits = [];
+  const coverage = /* @__PURE__ */ new Set();
+  if (spans.length > 0) coverage.add("edits");
+  spans.forEach((span, seq) => {
+    if (span.isEdit && span.file) {
+      edits.push({
+        seq,
+        sessionIndex: span.sessionIndex,
+        turnIndex: span.turnIndex,
+        status: span.status,
+        file: span.file
+      });
+      return;
+    }
+    const commandText = span.command === void 0 ? null : extractCommandText(span.command);
+    if (commandText === null) return;
+    coverage.add("commands");
+    const segments2 = splitCommandSegments(commandText);
+    const classifiedSegments = segments2.map((segment) => classifyCommand(segment)).filter((c) => c.kind !== "other");
+    const strippedText = segments2.join(" && ");
+    const toEmit = classifiedSegments.length > 0 ? classifiedSegments : strippedText ? [classifyCommand(strippedText)] : [];
+    for (const classified of toEmit) {
+      runs.push({
+        seq,
+        sessionIndex: span.sessionIndex,
+        turnIndex: span.turnIndex,
+        status: span.status,
+        kind: classified.kind,
+        normalized: classified.normalized
+      });
+    }
+  });
+  return { runs, edits, coverage };
+}
+var INPUT_CAP = 4096;
+function asText(value) {
+  return typeof value === "string" ? value : JSON.stringify(value);
+}
+function cutCodePoints(text, max) {
+  if (text.length <= max) return text;
+  let end = 0;
+  let count = 0;
+  while (end < text.length && count < max) {
+    const code = text.charCodeAt(end);
+    end += code >= 55296 && code <= 56319 && end + 1 < text.length ? 2 : 1;
+    count += 1;
+  }
+  return text.slice(0, end);
+}
+function storedCommand(call) {
+  var _a;
+  if (!call.input) return void 0;
+  const input = cutCodePoints(JSON.stringify([{ role: "user", content: asText(call.input) }]), INPUT_CAP);
+  try {
+    const parsed = JSON.parse(input);
+    if (Array.isArray(parsed) && typeof ((_a = parsed[0]) == null ? void 0 : _a.content) === "string") return parsed[0].content;
+    return void 0;
+  } catch {
+    return input;
+  }
+}
+var millis = (iso) => {
+  if (!iso) return 0;
+  const time = Date.parse(iso);
+  return Number.isFinite(time) ? time : 0;
+};
+function spansOfSession(session, sessionIndex) {
+  const timed = [];
+  let cursor = millis(session.startedAt);
+  for (const turn of session.turns) {
+    const turnStart = millis(turn.ts) || cursor + 1;
+    cursor = Math.max(cursor + 1, turnStart);
+    turn.toolCalls.forEach((call, seq) => {
+      const command = storedCommand(call);
+      timed.push({
+        time: cursor + seq + 1,
+        name: `agent.tool.${call.name}`,
+        span: {
+          sessionIndex,
+          turnIndex: turn.index,
+          toolName: call.name,
+          status: call.status,
+          isEdit: call.isEdit === true,
+          ...call.file ? { file: call.file } : {},
+          ...command !== void 0 ? { command } : {}
+        }
+      });
+    });
+  }
+  return timed;
+}
+var byStart = (a, b) => a.startedAt < b.startedAt ? -1 : a.startedAt > b.startedAt ? 1 : a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+function orderSessions(sessions) {
+  const tops = sessions.filter((session) => session.subagent === void 0).sort(byStart);
+  const topIds = new Set(tops.map((session) => session.id));
+  const orphans = sessions.filter((session) => {
+    var _a;
+    return session.subagent !== void 0 && !topIds.has((_a = session.subagent.parentSessionId) != null ? _a : "");
+  }).sort(byStart);
+  return [...tops, ...orphans];
+}
+function sessionsToTimeline(sessions) {
+  const out = [];
+  orderSessions(sessions).forEach((session, sessionIndex) => {
+    const children = sessions.filter((child) => child.subagent !== void 0 && child.subagent.parentSessionId === session.id).sort(byStart);
+    const timed = [session, ...children].flatMap((member) => spansOfSession(member, sessionIndex));
+    const ordered = timed.map((entry, index) => ({ entry, index })).sort((a, b) => a.entry.time - b.entry.time || (a.entry.name < b.entry.name ? -1 : a.entry.name > b.entry.name ? 1 : 0) || a.index - b.index);
+    for (const { entry } of ordered) out.push(entry.span);
+  });
+  return out;
+}
 
-export { CONTEXT_PIN_FILENAME, CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_SOURCE_CONFIG_PATH, classifyTree, emitTree, generatedHeaderSource, normalizePath, normalizeRepoName, parseGoverns, parseOuterlayerConfig, parsePolicy, splitRawFile };
+export { CONTEXT_PIN_FILENAME, CONTEXT_PIN_SCHEMA_VERSION, CONTEXT_SOURCE_CONFIG_PATH, classifyTree, emitTree, extractFacts, generatedHeaderSource, normalizePath, normalizeRepoName, orderSessions, parseGoverns, parseOuterlayerConfig, parsePolicy, sessionsToTimeline, splitRawFile };

package/dist/{chunk-AX23QKHS.js → chunk-CRLAB4PM.js}

@@ -2,7 +2,7 @@
 import { createRequire } from 'node:module';
 import { runnerUnit, UNIT_MARKER } from './chunk-FBTE2A2X.js';
 import { checkFit } from './chunk-JKIWMRFH.js';
-import { builtinKind } from './chunk-PWBILI5P.js';
+import { builtinKind } from './chunk-7KI224YS.js';
 import { runnerDir } from './chunk-ZM2IMMYN.js';
 import { dirname } from 'path';
 import { spawnSync } from 'child_process';