chainlesschain 0.162.35 → 0.162.37

package/src/commands/permissions.js

@@ -0,0 +1,211 @@
+/**
+ * cc permissions — inspect, dry-run, and edit the `.claude/settings.json`
+ * permission ruleset (Claude-Code `permissions.{allow,ask,deny}` parity).
+ *
+ *   cc permissions list [--json]                merged ruleset + source file
+ *   cc permissions test <tool> <args...>        dry-run: which rule decides?
+ *   cc permissions add <allow|ask|deny> <rule>  append a rule to a settings file
+ *       [--local | --user]                      (default target: project)
+ *
+ * The ruleset is loaded by settings-loader (user < project < local < env) and
+ * evaluated by permission-rules (deny > ask > allow). This command only reads
+ * and edits the files / runs the engine — it does not yet gate the agent tool
+ * loop (that wiring is a separate, riskier step).
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+const KIND_COLOR = {
+  allow: chalk.green,
+  ask: chalk.yellow,
+  deny: chalk.red,
+};
+
+/** Resolve an umbrella token (Bash) to a concrete tool name for dry-run. */
+function resolveConcreteTool(token, groups) {
+  const t = String(token || "");
+  const lower = t.toLowerCase();
+  if (Object.prototype.hasOwnProperty.call(groups, lower)) {
+    return groups[lower][0];
+  }
+  return t;
+}
+
+/** Build the tool args object a dry-run target needs from positional args. */
+function buildArgs(tool, positional, rulesMod) {
+  const joined = positional.join(" ").trim();
+  if (rulesMod.COMMAND_TOOLS.has(tool)) return { command: joined };
+  if (rulesMod.PATH_TOOLS.has(tool)) return { path: positional[0] || "" };
+  if (rulesMod.URL_TOOLS.has(tool)) return { url: positional[0] || "" };
+  return {};
+}
+
+export function registerPermissionsCommand(program) {
+  const cmd = program
+    .command("permissions")
+    .alias("perms")
+    .description(
+      "Inspect / dry-run / edit .claude/settings.json permission rules",
+    );
+
+  // ── list ──────────────────────────────────────────────────────────────
+  cmd
+    .command("list")
+    .alias("ls")
+    .description("Show the merged permission ruleset and where each rule came from")
+    .option("--json", "Output as JSON")
+    .option("--settings <file>", "Also merge an explicit settings file")
+    .action(async (options) => {
+      try {
+        const { loadSettings } = await import("../lib/settings-loader.cjs");
+        const { rules, sources, files } = loadSettings({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+        if (options.json) {
+          console.log(JSON.stringify({ rules, sources, files }, null, 2));
+          return;
+        }
+        const total =
+          rules.allow.length + rules.ask.length + rules.deny.length;
+        if (total === 0) {
+          logger.log(
+            chalk.gray(
+              "No permission rules. Add one: cc permissions add deny \"Bash(rm:*)\"\n" +
+                "(or create .claude/settings.json with a permissions block)",
+            ),
+          );
+          return;
+        }
+        for (const kind of ["deny", "ask", "allow"]) {
+          if (rules[kind].length === 0) continue;
+          logger.log(KIND_COLOR[kind].bold(`${kind} (${rules[kind].length})`));
+          for (const rule of rules[kind]) {
+            const src = sources[`${kind}:${rule}`] || "?";
+            logger.log(`  ${rule.padEnd(34)} ${chalk.gray(src)}`);
+          }
+        }
+        if (files.length) {
+          logger.log(chalk.dim(`\nsources: ${files.join(", ")}`));
+        }
+      } catch (err) {
+        logger.error(chalk.red(`permissions list failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── test (dry-run) ─────────────────────────────────────────────────────
+  cmd
+    .command("test <tool> [args...]")
+    .description(
+      'Dry-run a tool call against the ruleset, e.g. permissions test run_shell "git push"',
+    )
+    .option("--json", "Output as JSON")
+    .option("--settings <file>", "Also merge an explicit settings file")
+    .action(async (tool, args, options) => {
+      try {
+        const { loadSettings, ruleSource } =
+          await import("../lib/settings-loader.cjs");
+        // .cjs default-export interop: module.exports surfaces as `.default`.
+        const rulesMod = await import("../lib/permission-rules.cjs");
+        const mod = rulesMod.default || rulesMod;
+
+        const { rules, sources } = loadSettings({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+        const concrete = resolveConcreteTool(tool, mod.TOOL_GROUPS);
+        const toolArgs = buildArgs(concrete, args || [], mod);
+        const result = mod.evaluatePermissionRules({
+          tool: concrete,
+          args: toolArgs,
+          cwd: process.cwd(),
+          rules,
+        });
+        const decision = result.decision || "fallthrough";
+        const source = result.rule
+          ? ruleSource(sources, result.decision, result.rule)
+          : null;
+
+        if (options.json) {
+          console.log(
+            JSON.stringify(
+              { tool: concrete, args: toolArgs, decision, rule: result.rule, source },
+              null,
+              2,
+            ),
+          );
+          return;
+        }
+
+        const color = KIND_COLOR[result.decision] || chalk.gray;
+        logger.log(
+          `${chalk.bold(concrete)} ${chalk.gray(JSON.stringify(toolArgs))}`,
+        );
+        logger.log(`  decision: ${color.bold(decision)}`);
+        if (result.rule) {
+          logger.log(`  rule:     ${result.rule}`);
+          if (source) logger.log(`  source:   ${chalk.gray(source)}`);
+        } else {
+          logger.log(
+            chalk.gray(
+              "  no rule matched → falls back to risk-tier / --permission-mode logic",
+            ),
+          );
+        }
+      } catch (err) {
+        logger.error(chalk.red(`permissions test failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  // ── add ────────────────────────────────────────────────────────────────
+  cmd
+    .command("add <decision> <rule>")
+    .description("Append a rule (allow|ask|deny) to a settings file")
+    .option("--local", "Write to .claude/settings.local.json (personal, gitignored)")
+    .option("--user", "Write to ~/.claude/settings.json (all projects)")
+    .action(async (decision, rule, options) => {
+      try {
+        const kind = String(decision || "").toLowerCase();
+        if (!["allow", "ask", "deny"].includes(kind)) {
+          logger.error(
+            chalk.red(`decision must be allow | ask | deny (got "${decision}")`),
+          );
+          process.exitCode = 1;
+          return;
+        }
+        const rulesMod = await import("../lib/permission-rules.cjs");
+        const mod = rulesMod.default || rulesMod;
+        if (!mod.parseRule(rule)) {
+          logger.error(
+            chalk.red(
+              `not a valid rule: "${rule}" (expected Tool or Tool(pattern), e.g. Bash(rm:*))`,
+            ),
+          );
+          process.exitCode = 1;
+          return;
+        }
+
+        const scope = options.user ? "user" : options.local ? "local" : "project";
+        const { addRule } = await import("../lib/settings-loader.cjs");
+        const { file, added } = addRule({
+          cwd: process.cwd(),
+          kind,
+          rule,
+          scope,
+        });
+        if (!added) {
+          logger.log(chalk.gray(`already present in ${file}: ${kind} ${rule}`));
+          return;
+        }
+        logger.log(
+          `${KIND_COLOR[kind].bold("✓ " + kind)} ${rule} ${chalk.gray("→ " + file)}`,
+        );
+      } catch (err) {
+        logger.error(chalk.red(`permissions add failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/commands/statusline.js

@@ -0,0 +1,93 @@
+/**
+ * cc statusline — preview the configured `statusLine` (Claude-Code parity).
+ *
+ *   cc statusline            preview the rendered status line
+ *   cc statusline show       show the resolved config (+ source)
+ *
+ * Configure in .claude/settings.json:
+ *   { "statusLine": { "type": "command", "command": "~/.claude/status.sh" } }
+ * The command receives a JSON context on stdin and its first stdout line is the
+ * status line (shown above the REPL prompt each turn).
+ */
+
+import chalk from "chalk";
+import { logger } from "../lib/logger.js";
+
+export function registerStatuslineCommand(program) {
+  const cmd = program
+    .command("statusline")
+    .alias("status-line")
+    .description("Preview / show the .claude/settings.json statusLine");
+
+  cmd
+    .command("preview", { isDefault: true })
+    .description("Render the configured status line once")
+    .option("--model <m>", "Model to pass in the context", "opus")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { loadStatusLineConfig, buildContext, renderStatusLine } =
+          await import("../lib/status-line.cjs");
+        const cfg = loadStatusLineConfig({ cwd: process.cwd() });
+        if (!cfg) {
+          logger.log(
+            chalk.gray(
+              'No statusLine configured. Add to .claude/settings.json:\n' +
+                '  { "statusLine": { "type": "command", "command": "./status.sh" } }',
+            ),
+          );
+          return;
+        }
+        const line = renderStatusLine(
+          cfg,
+          buildContext({
+            sessionId: "preview",
+            model: options.model,
+            cwd: process.cwd(),
+          }),
+          { cwd: process.cwd() },
+        );
+        if (options.json) {
+          console.log(JSON.stringify({ config: cfg, line }, null, 2));
+          return;
+        }
+        if (line == null) {
+          logger.error(
+            chalk.red(
+              `statusLine command produced no output (or failed): ${cfg.command}`,
+            ),
+          );
+          process.exitCode = 1;
+          return;
+        }
+        process.stdout.write(line + "\n");
+      } catch (err) {
+        logger.error(chalk.red(`statusline preview failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+
+  cmd
+    .command("show")
+    .description("Show the resolved statusLine config")
+    .option("--json", "Output as JSON")
+    .action(async (options) => {
+      try {
+        const { loadStatusLineConfig } = await import("../lib/status-line.cjs");
+        const cfg = loadStatusLineConfig({ cwd: process.cwd() });
+        if (options.json) {
+          console.log(JSON.stringify(cfg, null, 2));
+          return;
+        }
+        if (!cfg) {
+          logger.log(chalk.gray("No statusLine configured."));
+          return;
+        }
+        logger.log(`command: ${chalk.cyan(cfg.command)}`);
+        logger.log(chalk.gray(`type: ${cfg.type}  padding: ${cfg.padding}`));
+      } catch (err) {
+        logger.error(chalk.red(`statusline show failed: ${err.message}`));
+        process.exitCode = 1;
+      }
+    });
+}

package/src/index.js

@@ -58,11 +58,15 @@ import { registerRCacheCommand } from "./commands/rcache.js";
 import { registerSessionCommand } from "./commands/session.js";
 import { registerCostCommand } from "./commands/cost.js";
 import { registerContextCommand } from "./commands/context.js";
-import { registerAgentsCommand } from "./commands/agents.js";
 import { registerCheckpointCommand } from "./commands/checkpoint.js";
 import { registerGoalCommand } from "./commands/goal.js";
 import { registerCommandCommand } from "./commands/command.js";
 import { registerCompactCommand } from "./commands/compact.js";
+import { registerLoopCommand } from "./commands/loop.js";
+import { registerPermissionsCommand } from "./commands/permissions.js";
+import { registerOutputStyleCommand } from "./commands/output-style.js";
+import { registerStatuslineCommand } from "./commands/statusline.js";
+import { registerIdeCommand } from "./commands/ide.js";
 import { registerConsolCommand } from "./commands/consol.js";
 import { registerImportCommand } from "./commands/import.js";
 import { registerExportCommand } from "./commands/export.js";
@@ -457,11 +461,15 @@ export function createProgram(opts = {}) {
   registerSessionCommand(program);
   registerCostCommand(program);
   registerContextCommand(program);
-  registerAgentsCommand(program);
   registerCheckpointCommand(program);
   registerGoalCommand(program);
   registerCommandCommand(program);
   registerCompactCommand(program);
+  registerLoopCommand(program);
+  registerPermissionsCommand(program);
+  registerOutputStyleCommand(program);
+  registerStatuslineCommand(program);
+  registerIdeCommand(program);
   registerConsolCommand(program);
 
   // Phase 2: Knowledge & content management

package/src/lib/agent-core.js

@@ -24,5 +24,12 @@ export {
   agentLoop,
   formatToolArgs,
   getActiveMcpServers,
+  listBackgroundShellTasks,
+  killAllBackgroundShellTasks,
   _accumulateOllamaStream,
+  _accumulateOpenAIStream,
+  _accumulateAnthropicStream,
+  _toAnthropicMessages,
+  _anthropicThinkingParams,
+  _normalizeAnthropicResponse,
 } from "../runtime/agent-core.js";

package/src/lib/agents.js

@@ -57,7 +57,12 @@ export function normalizeTools(tools) {
 export function agentDirs(cwd = process.cwd(), opts = {}) {
   const path = opts.deps?.path || _deps.path;
   const home = opts.home || homedir();
+  // Project-native first (highest precedence), then the Claude-Code-portable
+  // location (so existing `.claude/agents/*.md` work unchanged), then personal.
+  // discoverAgents reverses + last-write-wins, so `.chainlesschain/agents/`
+  // shadows `.claude/agents/` shadows `~/.claude/agents/` on a name clash.
   return [
+    { dir: path.join(cwd, ".chainlesschain", "agents"), scope: "project" },
     { dir: path.join(cwd, ".claude", "agents"), scope: "project" },
     { dir: path.join(home, ".claude", "agents"), scope: "personal" },
   ];

package/src/lib/hook-manager.js

@@ -40,6 +40,7 @@ export const HookEvents = {
   SessionEnd: "SessionEnd",
   PreCompact: "PreCompact",
   PostCompact: "PostCompact",
+  Notification: "Notification",
   UserPromptSubmit: "UserPromptSubmit",
   AssistantResponse: "AssistantResponse",
   AgentStart: "AgentStart",

package/src/lib/hook-runner.cjs

@@ -0,0 +1,183 @@
+"use strict";
+
+/**
+ * hook-runner — execute a Claude-Code `command` hook with the JSON protocol.
+ *
+ * Protocol (Claude-Code parity):
+ *   - the hook event payload is written to the command's STDIN as JSON;
+ *   - exit code 2          → BLOCK (reason = stderr) — the canonical "deny" path;
+ *   - exit code 0 + JSON stdout → honored decision:
+ *       { "decision": "block"|"approve"|"ask", "reason": "..." }
+ *       { "hookSpecificOutput": { "permissionDecision": "deny"|"allow"|"ask",
+ *                                 "permissionDecisionReason": "..." } }
+ *       { "continue": false, "stopReason": "..." }                → block
+ *       { "additionalContext": "..." }                            → continue
+ *   - any other non-zero   → non-blocking error (surfaced, never blocks);
+ *   - spawn failure / timeout → non-blocking (a broken hook must not wedge the
+ *                               agent — only an explicit block decision blocks).
+ *
+ * Returns a normalized `{ decision, reason, exitCode, stdout, stderr, ... }`.
+ * `_deps.spawnSync` is injected for unit tests (no real process needed).
+ */
+
+const cpDefault = require("node:child_process");
+
+const _deps = { spawnSync: cpDefault.spawnSync };
+
+const HOOK_DECISIONS = Object.freeze({
+  BLOCK: "block",
+  ALLOW: "allow",
+  ASK: "ask",
+  CONTINUE: "continue",
+});
+
+/** Parse a hook's stdout JSON into a normalized decision, or null if not JSON. */
+function tryParseDecision(stdout) {
+  const text = String(stdout || "").trim();
+  if (!text || text[0] !== "{") return null;
+  let obj;
+  try {
+    obj = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  // PreToolUse-specific permission decision
+  const hso = obj.hookSpecificOutput;
+  if (hso && hso.permissionDecision) {
+    const pd = String(hso.permissionDecision).toLowerCase();
+    const decision =
+      pd === "deny"
+        ? HOOK_DECISIONS.BLOCK
+        : pd === "ask"
+          ? HOOK_DECISIONS.ASK
+          : pd === "allow"
+            ? HOOK_DECISIONS.ALLOW
+            : HOOK_DECISIONS.CONTINUE;
+    return { decision, reason: hso.permissionDecisionReason || null };
+  }
+  // Generic decision field
+  if (obj.decision) {
+    const d = String(obj.decision).toLowerCase();
+    const decision =
+      d === "block" || d === "deny"
+        ? HOOK_DECISIONS.BLOCK
+        : d === "approve" || d === "allow"
+          ? HOOK_DECISIONS.ALLOW
+          : d === "ask"
+            ? HOOK_DECISIONS.ASK
+            : HOOK_DECISIONS.CONTINUE;
+    return { decision, reason: obj.reason || null };
+  }
+  // continue:false → stop/block
+  if (obj.continue === false) {
+    return {
+      decision: HOOK_DECISIONS.BLOCK,
+      reason: obj.stopReason || obj.reason || "hook requested stop",
+    };
+  }
+  return {
+    decision: HOOK_DECISIONS.CONTINUE,
+    reason: null,
+    additionalContext: obj.additionalContext || null,
+  };
+}
+
+/**
+ * Run one command hook. `input` is JSON-serialized to the hook's stdin.
+ *
+ * @param {string} command
+ * @param {object} [input]   the hook event payload (tool_name, tool_input, …)
+ * @param {object} [opts]    { timeout=60000, cwd, event }
+ * @returns {{ decision:string, reason:string|null, exitCode:number|null,
+ *            stdout?:string, stderr?:string, additionalContext?:string,
+ *            nonBlockingError?:boolean, error?:string }}
+ */
+function runCommandHook(command, input = {}, opts = {}) {
+  const { timeout = 60000, cwd, event } = opts;
+  if (!command) {
+    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode: 0 };
+  }
+  let res;
+  try {
+    res = _deps.spawnSync(command, {
+      input: JSON.stringify(input),
+      cwd: cwd || process.cwd(),
+      encoding: "utf-8",
+      timeout,
+      shell: true,
+      maxBuffer: 8 * 1024 * 1024,
+      env: {
+        ...process.env,
+        CLAUDE_HOOK_EVENT: event || input.hook_event_name || "",
+      },
+    });
+  } catch (err) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: `hook spawn failed: ${err.message}`,
+      exitCode: null,
+      error: err.message,
+      nonBlockingError: true,
+    };
+  }
+  // spawnSync surfaces timeout/ENOENT on res.error (status null) — non-blocking.
+  if (res.error) {
+    return {
+      decision: HOOK_DECISIONS.CONTINUE,
+      reason: `hook error: ${res.error.message}`,
+      exitCode: null,
+      stdout: String(res.stdout || ""),
+      stderr: String(res.stderr || ""),
+      error: res.error.message,
+      nonBlockingError: true,
+    };
+  }
+  const exitCode = res.status;
+  const stdout = String(res.stdout || "");
+  const stderr = String(res.stderr || "");
+
+  if (exitCode === 2) {
+    return {
+      decision: HOOK_DECISIONS.BLOCK,
+      reason: stderr.trim() || "hook exited 2 (blocked)",
+      exitCode,
+      stdout,
+      stderr,
+    };
+  }
+  if (exitCode === 0) {
+    const parsed = tryParseDecision(stdout);
+    if (parsed) return { ...parsed, exitCode, stdout, stderr };
+    return { decision: HOOK_DECISIONS.CONTINUE, reason: null, exitCode, stdout, stderr };
+  }
+  // Other non-zero → non-blocking error.
+  return {
+    decision: HOOK_DECISIONS.CONTINUE,
+    reason: stderr.trim() || `hook exited ${exitCode}`,
+    exitCode,
+    stdout,
+    stderr,
+    nonBlockingError: true,
+  };
+}
+
+/**
+ * Run a list of command hooks in order; first BLOCK (or ASK) short-circuits.
+ * @returns {{ decision, reason, hook?, results }}
+ */
+function runHooks(commandHooks, input = {}, opts = {}) {
+  const results = [];
+  for (const h of commandHooks || []) {
+    const r = runCommandHook(h.command, input, {
+      ...opts,
+      timeout: h.timeout != null ? h.timeout * 1000 : opts.timeout,
+    });
+    results.push({ command: h.command, ...r });
+    if (r.decision === HOOK_DECISIONS.BLOCK || r.decision === HOOK_DECISIONS.ASK) {
+      return { decision: r.decision, reason: r.reason, hook: h.command, results };
+    }
+  }
+  return { decision: HOOK_DECISIONS.CONTINUE, reason: null, results };
+}
+
+module.exports = { runCommandHook, runHooks, tryParseDecision, HOOK_DECISIONS, _deps };