@anyslate/cli 0.1.0 → 0.2.0

package/src/hooks.mjs

@@ -1,15 +1,44 @@
 // Hook payload shaping.
 //
 // Claude Code lifecycle hooks pipe a JSON event on stdin. We're tolerant:
-// missing / empty / non-JSON stdin is fine — we still produce a valid
+// missing / empty / non-JSON stdin is fine - we still produce a valid
 // activity_submit payload, just with less context. This keeps the CLI from
 // breaking a Claude Code session because of an unexpected hook shape.
 //
 // This module is pure (no I/O) so it can be unit-tested directly.
+//
+// ---------------------------------------------------------------------------
+// W13 — structured activity ledger
+// ---------------------------------------------------------------------------
+// Live testing showed a hook-style note ("Claude Code Bash completed") merges
+// as a no-op: decisions_added 0, tasks_added 0, tasks_completed 0. The
+// extractor is correct — the note genuinely contains nothing.
+//
+// So hooks now emit structured FACTS as first-class payload fields, derived
+// from the Claude Code event (tool_name + tool_input + tool_response):
+//
+//     files_touched : string[]
+//     commands_run  : string[]
+//     exit_status   : string | number
+//
+// INVARIANT: these are machine-derived observations and belong in a dedicated
+// activity/ledger section of the memory page. They must NEVER be folded into
+// Decisions or Open Tasks, which stay human/LLM-authored. That is why they are
+// separate fields and are deliberately NOT concatenated into `notes` — `notes`
+// is the prose channel the extractor mines for decisions and tasks, and
+// polluting it would manufacture fake decisions out of shell commands.
+//
+// There is no LLM call anywhere on this path (the Cost Governor is untouched).
 
 const TRUNC_NOTES = 4_000;
 const TRUNC_EXCERPT = 16_000;
 
+/** Caps for the structured ledger fields — keep the payload bounded. */
+const MAX_FILES = 50;
+const MAX_COMMANDS = 20;
+const MAX_COMMAND_CHARS = 2_000;
+const MAX_PATH_CHARS = 512;
+
 /**
  * @param {string|null|undefined} raw
  * @returns {Record<string, unknown>}
@@ -34,6 +63,99 @@ function clipString(v, cap) {
   return v.slice(0, cap);
 }
 
+/**
+ * File paths the tool call touched.
+ *
+ * @param {unknown} toolInput
+ * @param {unknown} toolResponse
+ * @returns {string[]}
+ */
+export function extractFilesTouched(toolInput, toolResponse) {
+  const out = [];
+  const push = (v) => {
+    if (typeof v !== 'string') return;
+    const s = v.trim();
+    if (!s || s.length > MAX_PATH_CHARS) return;
+    if (!out.includes(s)) out.push(s);
+  };
+
+  const scan = (obj) => {
+    if (!obj || typeof obj !== 'object') return;
+    for (const key of ['file_path', 'filePath', 'path', 'notebook_path', 'notebookPath']) {
+      push(obj[key]);
+    }
+    for (const key of ['file_paths', 'filePaths', 'paths', 'files']) {
+      const arr = obj[key];
+      if (Array.isArray(arr)) for (const v of arr) push(typeof v === 'string' ? v : v?.file_path);
+    }
+    // MultiEdit-style: edits: [{ file_path, ... }]
+    const edits = obj.edits ?? obj.changes;
+    if (Array.isArray(edits)) for (const e of edits) push(e?.file_path ?? e?.filePath ?? e?.path);
+  };
+
+  scan(toolInput);
+  scan(toolResponse);
+  return out.slice(0, MAX_FILES);
+}
+
+/**
+ * Shell commands the tool call ran.
+ *
+ * @param {unknown} toolInput
+ * @returns {string[]}
+ */
+export function extractCommandsRun(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return [];
+  const out = [];
+  const push = (v) => {
+    if (typeof v !== 'string') return;
+    const s = v.trim();
+    if (!s) return;
+    const clipped = s.length > MAX_COMMAND_CHARS ? s.slice(0, MAX_COMMAND_CHARS) : s;
+    if (!out.includes(clipped)) out.push(clipped);
+  };
+  push(toolInput.command);
+  push(toolInput.cmd);
+  push(toolInput.script);
+  const arr = toolInput.commands;
+  if (Array.isArray(arr)) for (const v of arr) push(v);
+  return out.slice(0, MAX_COMMANDS);
+}
+
+/**
+ * Normalized outcome of the tool call. Returns `undefined` when the event
+ * carries no outcome signal at all — an absent field is honest, `"unknown"`
+ * is noise.
+ *
+ * @param {unknown} toolResponse
+ * @returns {string|number|undefined}
+ */
+export function extractExitStatus(toolResponse) {
+  if (toolResponse == null) return undefined;
+  if (typeof toolResponse !== 'object') return undefined;
+
+  for (const key of ['exit_code', 'exitCode', 'returncode', 'returnCode', 'status_code']) {
+    const v = toolResponse[key];
+    if (typeof v === 'number' && Number.isFinite(v)) return v;
+    if (typeof v === 'string' && v.trim() && Number.isFinite(Number(v))) return Number(v);
+  }
+  for (const key of ['is_error', 'isError', 'error']) {
+    const v = toolResponse[key];
+    if (v === true) return 'error';
+    if (typeof v === 'string' && v.trim()) return 'error';
+  }
+  for (const key of ['success', 'ok']) {
+    const v = toolResponse[key];
+    if (v === true) return 'success';
+    if (v === false) return 'error';
+  }
+  const status = toolResponse.status;
+  if (typeof status === 'string' && status.trim()) return status.trim();
+  if (typeof status === 'number' && Number.isFinite(status)) return status;
+  if (toolResponse.is_error === false || toolResponse.isError === false) return 'success';
+  return undefined;
+}
+
 /**
  * @param {object} args
  * @param {'session-start'|'post-tool-use'|'stop'} args.hook
@@ -52,6 +174,8 @@ export function buildHookSubmission({ hook, event, host = 'claude-code', session
 
   const toolName = pickString(event.tool_name) || pickString(event.toolName) || null;
   const transcriptPath = pickString(event.transcript_path);
+  const toolInput = event.tool_input ?? event.toolInput ?? null;
+  const toolResponse = event.tool_response ?? event.toolResponse ?? null;
 
   let kind;
   let defaultNote;
@@ -74,9 +198,26 @@ export function buildHookSubmission({ hook, event, host = 'claude-code', session
       throw new Error(`unknown hook: ${hook}`);
   }
 
-  const conversationExcerpt = clipString(stringify(event.tool_response), TRUNC_EXCERPT);
+  const conversationExcerpt = clipString(stringify(toolResponse), TRUNC_EXCERPT);
+
+  // W13 — structured ledger facts. Never merged into `notes`.
+  const filesTouched = extractFilesTouched(toolInput, toolResponse);
+  const commandsRun = extractCommandsRun(toolInput);
+  const exitStatus = extractExitStatus(toolResponse);
 
-  const payload = stripUndefined({
+  // Session boundaries are real ledger entries — "started work in /repo/x",
+  // "session ended" — not content-free pings. Without a ledger field the
+  // server classifies them as liveness-only and files them as `failed`, which
+  // would put two alarming rows in the user's Activity panel for every single
+  // Claude Code session, forever. `cwd` is what makes them legible on the
+  // page (it names the repo the work happened in).
+  const cwd =
+    pickString(event.cwd) ||
+    pickString(event.working_directory) ||
+    pickString(event.workingDirectory) ||
+    (typeof process !== 'undefined' && typeof process.cwd === 'function' ? process.cwd() : null);
+
+  const payload = stripEmpty({
     notes: clipString(notes ?? defaultNote, TRUNC_NOTES),
     session_id: sessionIdHint || undefined,
     host_hint: host,
@@ -85,6 +226,10 @@ export function buildHookSubmission({ hook, event, host = 'claude-code', session
     transcript_path: transcriptPath,
     confidence: hook === 'post-tool-use' ? 0.85 : 0.9,
     client_checkpoint_id: pickString(event.client_checkpoint_id),
+    files_touched: filesTouched.length ? filesTouched : undefined,
+    commands_run: commandsRun.length ? commandsRun : undefined,
+    exit_status: exitStatus,
+    cwd: cwd || undefined,
   });
 
   return {
@@ -102,9 +247,20 @@ function mapToolToKind(toolName) {
   if (!toolName) return 'topic_shift';
   const lower = toolName.toLowerCase();
   if (lower === 'edit' || lower === 'write' || lower === 'multiedit' || lower === 'create') {
-    return 'artifact_produced';
+    // NOT `artifact_produced`. That kind is a contract: "I stored an artifact,
+    // here is its ref in artifact_refs". A lifecycle hook stores nothing — it
+    // only observes that a file was touched, which W13 now carries properly in
+    // the `files_touched` ledger field.
+    //
+    // Claiming `artifact_produced` with an empty `artifact_refs` is precisely
+    // the "agent said it produced a file it never stored" shape that the
+    // server-side guard (activity-promote.ts:317) rejects, so every approved
+    // edit would have died with `artifact_refs_required`. It also tripped
+    // classifier rule #1, forcing a manual approval for every single edit —
+    // the busiest event in a Claude Code session.
+    return 'task_completed';
   }
-  if (lower === 'bash' || lower === 'shell' || lower === 'run') {
+  if (lower === 'bash' || lower === 'shell' || lower === 'run' || lower === 'gitcommit' || lower === 'git_commit' || lower === 'git commit') {
     return 'task_completed';
   }
   return 'topic_shift';
@@ -124,10 +280,16 @@ function stringify(v) {
   }
 }
 
-/** @template T @param {T} obj @returns {T} */
-function stripUndefined(obj) {
+/**
+ * Drop both `undefined` AND `null`. `pickString` yields `null` for absent
+ * fields, so `transcript_path: null` and `client_checkpoint_id: null` used to
+ * leak onto every single submission.
+ *
+ * @template T @param {T} obj @returns {T}
+ */
+function stripEmpty(obj) {
   for (const k of Object.keys(obj)) {
-    if (obj[k] === undefined) delete obj[k];
+    if (obj[k] === undefined || obj[k] === null) delete obj[k];
   }
   return obj;
 }

package/src/index.mjs

@@ -4,6 +4,7 @@
 //   anyslate checkpoint --note "..."
 //   anyslate upload-artifact --session <id> --kind <kind> [--file <path>]
 //   anyslate login --token <bearer>
+//   anyslate doctor
 //   anyslate version
 //   anyslate help
 
@@ -11,8 +12,12 @@ import { runHook } from './commands/hook.mjs';
 import { runCheckpoint } from './commands/checkpoint.mjs';
 import { runUploadArtifact } from './commands/upload-artifact.mjs';
 import { runLogin } from './commands/login.mjs';
+import { runDoctor } from './commands/doctor.mjs';
+import { isCaptureDisabled, DISABLED_NOTICE } from './config.mjs';
+import { VERSION } from './version.mjs';
 
-const VERSION = '0.1.0';
+/** Subcommands that talk to the network on the user's behalf (capture). */
+const CAPTURE_COMMANDS = new Set(['hook', 'checkpoint', 'upload-artifact']);
 
 const HELP = `anyslate ${VERSION}
 
@@ -26,16 +31,34 @@ usage:
       failure).
 
   anyslate upload-artifact --session <id> --kind <kind> [--file <path>]
-      Upload a file (or stdin) as an MCP artifact. Returns cloud://artifact/<id>.
+      Upload a UTF-8 file (or stdin, up to 5 MB) as an MCP artifact.
+      Prints cloud://artifact/<id>.
 
   anyslate login --token <BEARER> [--handle <ID>] [--api-url <URL>]
-      Save credentials to ~/.anyslate/cli.json (mode 0600).
+                 [--force] [--no-verify]
+      Verify the token against the server, then save credentials to
+      ~/.anyslate/cli.json (mode 0600). Exits non-zero and writes nothing if
+      verification fails. --api-url takes the service ROOT (no /mcp suffix).
+      --force writes anyway; --no-verify skips the live check.
+
+  anyslate doctor [--deep]
+      Diagnose the whole setup: config layers, token format, URL shape,
+      reachability, token validity, scopes, handle binding, PATH, Claude Code
+      hook wiring, and the last run outcome. Exits non-zero on any FAIL.
+      --deep additionally writes one probe row to your Activity feed.
 
 env:
-  ANYSLATE_API_URL    override config (e.g. dev workers.dev URL)
+  ANYSLATE_API_URL    override config (service ROOT, e.g. dev workers.dev URL)
   ANYSLATE_MCP_TOKEN  override config token
-  ANYSLATE_HANDLE     override config handle
+  ANYSLATE_HANDLE     override config handle (handle ids are mh_-prefixed)
+  ANYSLATE_HOME       override ~/.anyslate
   ANYSLATE_VERBOSE    if set, hooks print JSON results to stdout
+  ANYSLATE_STDIN_TIMEOUT_MS
+                      idle timeout while reading stdin (default 10000; 0
+                      disables). Raise it for very slow pipes.
+  ANYSLATE_DISABLE=1  kill switch: hook / checkpoint / upload-artifact make no
+                      network call and exit 0. \`doctor\` and \`login\` still run
+                      so you can diagnose and set up while capture is off.
 `;
 
 /**
@@ -44,6 +67,15 @@ env:
  */
 export async function main(argv) {
   const cmd = argv[0];
+
+  // The kill switch is enforced centrally so no capture subcommand can miss it.
+  // Each capture command also re-checks, which keeps them safe when imported
+  // directly (tests, embedding).
+  if (CAPTURE_COMMANDS.has(cmd) && isCaptureDisabled(process.env)) {
+    process.stderr.write(`${DISABLED_NOTICE}\n`);
+    return 0;
+  }
+
   switch (cmd) {
     case 'hook':
       return runHook(argv.slice(1));
@@ -53,6 +85,8 @@ export async function main(argv) {
       return runUploadArtifact(argv.slice(1));
     case 'login':
       return runLogin(argv.slice(1));
+    case 'doctor':
+      return runDoctor(argv.slice(1));
     case 'version':
     case '--version':
     case '-v':

package/src/io.mjs

@@ -0,0 +1,30 @@
+// Injectable stdout/stderr.
+//
+// Commands must never reach for `process.stdout` directly: tests that
+// monkeypatch it also swallow the test reporter's own output, which silently
+// hides results. Every command takes `{stdout, stderr}` in its deps and
+// defaults to the real streams.
+
+/**
+ * @param {{stdout?: {write: (s: string) => unknown}, stderr?: {write: (s: string) => unknown}}} [deps]
+ */
+export function makeIo(deps = {}) {
+  return {
+    out: deps.stdout ?? process.stdout,
+    err: deps.stderr ?? process.stderr,
+  };
+}
+
+/** A collector usable anywhere an io stream is expected. */
+export function memoryStream() {
+  let text = '';
+  return {
+    write(chunk) {
+      text += String(chunk);
+      return true;
+    },
+    get text() {
+      return text;
+    },
+  };
+}