@event4u/agent-config 9.10.0 → 9.12.0

package/dist/cli-delegate/cmd_analyze_session.js

@@ -0,0 +1,294 @@
+#!/usr/bin/env tsx
+import { createRequire as __acCreateRequire } from 'node:module'; const require = globalThis.require ?? __acCreateRequire(import.meta.url);
+import {
+  StateLoadError,
+  load_state
+} from "./chunk-GME3Q44L.js";
+import {
+  ProjectRootError,
+  resolve_project_root
+} from "./chunk-HJ6DAJHR.js";
+import "./chunk-NDJLNC6Q.js";
+import "./chunk-J55WI3RR.js";
+
+// src/scripts/_cli/cmd_analyze_session.ts
+import * as fs from "node:fs";
+import * as path from "node:path";
+import process from "node:process";
+import { fileURLToPath, pathToFileURL } from "node:url";
+var _HERE = fileURLToPath(import.meta.url);
+var CONTEXT_HYGIENE_RELATIVE = path.join(
+  "agents",
+  "runtime",
+  "state",
+  "context-hygiene.json"
+);
+var SystemExitError = class extends Error {
+  constructor(code) {
+    super(`system-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+var ArgparseExit = class extends Error {
+  constructor(code) {
+    super(`argparse-exit-${code}`);
+    this.code = code;
+  }
+  code;
+};
+function eprint(line = "") {
+  process.stderr.write(line + "\n");
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function _resolve_root(arg) {
+  try {
+    const [root] = resolve_project_root(arg, { cwd: process.cwd() });
+    return root;
+  } catch (exc) {
+    if (exc instanceof ProjectRootError) {
+      eprint(`\u274C  analyze-session: ${exc.message}`);
+      throw new SystemExitError(2);
+    }
+    throw exc;
+  }
+}
+function relativeToOrNull(p, base) {
+  const rel = path.relative(base, p);
+  if (rel === "") return rel;
+  if (rel.startsWith("..") || path.isAbsolute(rel)) {
+    return null;
+  }
+  return rel;
+}
+function _load_context_hygiene(project_root) {
+  const p = path.join(project_root, CONTEXT_HYGIENE_RELATIVE);
+  if (!fs.existsSync(p)) {
+    return null;
+  }
+  let text;
+  try {
+    text = fs.readFileSync(p, "utf-8");
+  } catch {
+    return null;
+  }
+  let payload;
+  try {
+    payload = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  return isPlainObject(payload) ? payload : null;
+}
+function intOrUnknown(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return String(Math.trunc(value));
+  }
+  return "?";
+}
+function render_report(state, hygiene) {
+  const lines = [];
+  lines.push("# Session analysis");
+  lines.push("");
+  const changes = Array.isArray(state["changes"]) ? state["changes"] : [];
+  lines.push(`## Files touched (${changes.length})`);
+  lines.push("");
+  if (changes.length === 0) {
+    lines.push("_No files recorded as changed._");
+  } else {
+    for (const change of changes) {
+      if (!isPlainObject(change)) continue;
+      const file = typeof change["file"] === "string" ? change["file"] : "(unknown file)";
+      const summary = typeof change["summary"] === "string" && change["summary"].length > 0 ? ` \u2014 ${change["summary"]}` : "";
+      lines.push(`- \`${file}\`${summary}`);
+    }
+  }
+  lines.push("");
+  const outcomes = isPlainObject(state["outcomes"]) ? state["outcomes"] : {};
+  const directives = Object.keys(outcomes).sort();
+  const blocked = directives.filter((d) => outcomes[d] === "blocked");
+  lines.push(`## Outcomes (${directives.length})`);
+  lines.push("");
+  if (directives.length === 0) {
+    lines.push("_No directive outcomes recorded._");
+  } else {
+    for (const directive of directives) {
+      const result = outcomes[directive];
+      const marker = result === "blocked" ? "\u26A0\uFE0F " : "";
+      lines.push(`- ${marker}\`${directive}\`: ${String(result)}`);
+    }
+  }
+  lines.push("");
+  if (blocked.length > 0) {
+    lines.push(`**Blocked directives (${blocked.length}):** ${blocked.join(", ")}`);
+    lines.push("");
+  }
+  const halts = Array.isArray(state["halts"]) ? state["halts"] : [];
+  lines.push(`## Halts (${halts.length})`);
+  lines.push("");
+  if (halts.length === 0) {
+    lines.push("_No halts recorded._");
+  } else {
+    lines.push(`This session recorded ${halts.length} halt(s).`);
+  }
+  lines.push("");
+  lines.push("## Tool activity");
+  lines.push("");
+  if (hygiene === null) {
+    lines.push("_Context-hygiene snapshot not available._");
+  } else {
+    const toolCalls = intOrUnknown(hygiene["tool_calls"]);
+    const consecutive = intOrUnknown(hygiene["consecutive_same_tool"]);
+    const loop = hygiene["loop_detected"] === true;
+    lines.push(`- Tool calls: ${toolCalls}`);
+    lines.push(`- Consecutive same-tool calls: ${consecutive}`);
+    lines.push(`- Loop detected: ${loop ? "yes" : "no"}`);
+  }
+  lines.push("");
+  lines.push("## Token / cost");
+  lines.push("");
+  lines.push("Token/cost: not tracked (no per-session source).");
+  lines.push("");
+  return lines.join("\n");
+}
+function _analyze_session(project_root, state_file) {
+  const target_state = state_file || path.join(project_root, ".work-state.json");
+  let state;
+  try {
+    state = load_state(target_state);
+  } catch (exc) {
+    if (exc instanceof StateLoadError) {
+      const rel = relativeToOrNull(target_state, project_root);
+      const shown = rel !== null ? rel : path.basename(target_state);
+      const msg = exc.message.split(target_state).join(shown);
+      eprint(`\u274C  analyze-session: ${msg}`);
+      return exc.exitCode;
+    }
+    throw exc;
+  }
+  const hygiene = _load_context_hygiene(project_root);
+  process.stdout.write(render_report(state, hygiene));
+  return 0;
+}
+var PROG = "agent-config analyze-session";
+var USAGE = `usage: ${PROG} [-h] [--project PROJECT] [--state-file STATE_FILE]
+`;
+var _HELP = `usage: ${PROG} [--project PATH] [--state-file PATH]
+
+Print a post-session report from on-disk runtime state. Read-only;
+no daemon, no network, no model calls.
+
+Sources read:
+  .work-state.json (version 1)
+    \xB7 changes  \u2014 files touched
+    \xB7 outcomes \u2014 per-directive success / blocked
+    \xB7 halts    \u2014 recorded halts
+  agents/runtime/state/context-hygiene.json
+    \xB7 tool_calls \xB7 consecutive_same_tool \xB7 loop_detected
+
+Token/cost is NOT reported \u2014 this package has no per-session token
+source (only video-specific telemetry).
+
+options:
+  --project PATH       project root (defaults to anchor walk from cwd)
+  --state-file PATH    .work-state.json path (default <root>/.work-state.json)
+  -h, --help           show this help and exit
+
+exit codes:
+  0  report rendered (a missing source file is noted, not fatal)
+  1  no recent run found (state file missing or unreadable)
+  2  invocation error (bad project root, bad --state-file path)
+`;
+function _argError(msg) {
+  process.stderr.write(USAGE);
+  process.stderr.write(`${PROG}: error: ${msg}
+`);
+  throw new ArgparseExit(2);
+}
+function _parse(argv) {
+  const opts = { project: null, state_file: null };
+  let i = 0;
+  while (i < argv.length) {
+    const a = argv[i];
+    if (a === "-h" || a === "--help") {
+      process.stdout.write(_HELP);
+      throw new ArgparseExit(0);
+    }
+    const eq = a.startsWith("--") ? a.indexOf("=") : -1;
+    const flag = eq >= 0 ? a.slice(0, eq) : a;
+    const inlineVal = eq >= 0 ? a.slice(eq + 1) : null;
+    if (flag === "--project" || flag === "--state-file") {
+      const dest = flag === "--project" ? "project" : "state_file";
+      let value;
+      if (inlineVal !== null) {
+        value = inlineVal;
+      } else {
+        if (i + 1 >= argv.length) {
+          _argError(`argument ${flag}: expected one argument`);
+        }
+        value = argv[i + 1];
+        i += 1;
+      }
+      opts[dest] = value;
+      i += 1;
+      continue;
+    }
+    _argError(`unrecognized arguments: ${a}`);
+  }
+  return opts;
+}
+function main(argv = null) {
+  const argv_list = argv !== null ? Array.from(argv) : process.argv.slice(2);
+  const opts = _parse(argv_list);
+  let project_root;
+  try {
+    project_root = _resolve_root(opts.project);
+  } catch (exc) {
+    if (exc instanceof SystemExitError) {
+      return exc.code;
+    }
+    throw exc;
+  }
+  return _analyze_session(project_root, opts.state_file);
+}
+function _isCliEntry() {
+  if (process.argv[1] === void 0) {
+    return false;
+  }
+  const argvUrl = pathToFileURL(path.resolve(process.argv[1])).href;
+  if (import.meta.url === argvUrl) {
+    return true;
+  }
+  try {
+    const here = fs.realpathSync(fileURLToPath(import.meta.url));
+    const argv = fs.realpathSync(path.resolve(process.argv[1]));
+    return here === argv;
+  } catch {
+    return false;
+  }
+}
+if (_isCliEntry() || process.argv[1] === _HERE) {
+  try {
+    process.exitCode = main(process.argv.slice(2));
+  } catch (e) {
+    if (e instanceof ArgparseExit) {
+      process.exitCode = e.code;
+    } else if (e instanceof SystemExitError) {
+      process.exitCode = e.code;
+    } else {
+      throw e;
+    }
+  }
+}
+export {
+  ArgparseExit,
+  SystemExitError,
+  _analyze_session,
+  _load_context_hygiene,
+  _parse,
+  _resolve_root,
+  main,
+  render_report
+};