chainlesschain 0.162.35 → 0.162.37

package/src/commands/cli-anything.js

@@ -6,6 +6,7 @@
 import chalk from "chalk";
 import { logger } from "../lib/logger.js";
 import { bootstrap, shutdown } from "../runtime/bootstrap.js";
+import { withQuietStdout } from "../runtime/quiet-stdout.js";
 import {
   ensureCliAnythingTables,
   detectPython,
@@ -17,6 +18,13 @@ import {
   listTools,
 } from "../lib/cli-anything-bridge.js";
 
+// bootstrap()/shutdown() log "[AppConfig] …" and "[DatabaseManager] …" via
+// console.info, which Node writes to stdout. That chatter corrupts the JSON
+// emitted by `--json` subcommands. Divert it to stderr (the diagnostic
+// channel) so stdout stays a pristine machine-readable payload.
+const quietBootstrap = (opts) => withQuietStdout(() => bootstrap(opts));
+const quietShutdown = () => withQuietStdout(() => shutdown());
+
 export function registerCliAnythingCommand(program) {
   const cliAny = program
     .command("cli-anything")
@@ -135,7 +143,7 @@ export function registerCliAnythingCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (name, opts) => {
       try {
-        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const ctx = await quietBootstrap({ verbose: program.opts().verbose });
         if (!ctx.db) {
           logger.error(
             "Database not available. Run `chainlesschain setup` first.",
@@ -154,7 +162,7 @@ export function registerCliAnythingCommand(program) {
           force: opts.force,
         });
 
-        await shutdown();
+        await quietShutdown();
 
         if (opts.json) {
           console.log(JSON.stringify(result, null, 2));
@@ -188,7 +196,7 @@ export function registerCliAnythingCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (opts) => {
       try {
-        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const ctx = await quietBootstrap({ verbose: program.opts().verbose });
         if (!ctx.db) {
           logger.error("Database not available.");
           process.exit(1);
@@ -197,7 +205,7 @@ export function registerCliAnythingCommand(program) {
         ensureCliAnythingTables(db);
 
         const tools = listTools(db);
-        await shutdown();
+        await quietShutdown();
 
         if (opts.json) {
           console.log(JSON.stringify(tools, null, 2));
@@ -241,7 +249,7 @@ export function registerCliAnythingCommand(program) {
     .option("--json", "Output as JSON")
     .action(async (name, opts) => {
       try {
-        const ctx = await bootstrap({ verbose: program.opts().verbose });
+        const ctx = await quietBootstrap({ verbose: program.opts().verbose });
         if (!ctx.db) {
           logger.error("Database not available.");
           process.exit(1);
@@ -250,7 +258,7 @@ export function registerCliAnythingCommand(program) {
         ensureCliAnythingTables(db);
 
         const result = removeTool(db, name);
-        await shutdown();
+        await quietShutdown();
 
         if (opts.json) {
           console.log(JSON.stringify(result, null, 2));

package/src/commands/command.js

@@ -145,8 +145,9 @@ export function registerCommandCommand(program) {
   // ── new (scaffold) ────────────────────────────────────────────────────
   cmd
     .command("new <name>")
-    .description("Scaffold a new command file under .claude/commands/")
+    .description("Scaffold a new command file (project-native .chainlesschain/commands/)")
     .option("--description <d>", "Frontmatter description")
+    .option("--claude", "Create under .claude/commands (Claude-Code-portable)")
     .option("--personal", "Create under ~/.claude/commands instead of project")
     .action(async (name, options) => {
       try {
@@ -154,9 +155,13 @@ export function registerCommandCommand(program) {
         const path = await import("node:path");
         const { homedir } = await import("node:os");
         const safe = String(name).replace(/^\//, "").replace(/:/g, "/");
+        // Project commands go to the native `.chainlesschain/commands/`; use
+        // --claude for the portable `.claude/commands/`, --personal for home.
         const root = options.personal
           ? path.join(homedir(), ".claude", "commands")
-          : path.join(process.cwd(), ".claude", "commands");
+          : options.claude
+            ? path.join(process.cwd(), ".claude", "commands")
+            : path.join(process.cwd(), ".chainlesschain", "commands");
         const file = path.join(root, `${safe}.md`);
         if (fs.existsSync(file)) {
           logger.error(chalk.red(`already exists: ${file}`));

package/src/commands/hook.js

@@ -29,9 +29,10 @@ export function registerHookCommand(program) {
   // hook list
   hook
     .command("list", { isDefault: true })
-    .description("List all registered hooks")
+    .description("List registered hooks (DB) + .claude/settings.json hooks")
     .option("--event <name>", "Filter by event name")
     .option("--enabled", "Show only enabled hooks")
+    .option("--settings <file>", "Also merge an explicit settings file")
     .option("--json", "Output as JSON")
     .action(async (options) => {
       try {
@@ -46,43 +47,76 @@ export function registerHookCommand(program) {
           enabledOnly: options.enabled,
         });
 
+        // .claude/settings.json `hooks` block (Claude-Code parity, decision-
+        // capable; distinct from the DB registry above which is observe-only).
+        const { loadHooks } = await import("../lib/settings-hooks.cjs");
+        const { hooks: settingsHooks, files: settingsFiles } = loadHooks({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+
         if (options.json) {
           console.log(
             JSON.stringify(
-              hooks.map((h) => ({
-                id: h.id,
-                event: h.event,
-                name: h.name,
-                type: h.type,
-                priority: h.priority,
-                enabled: h.enabled === 1,
-                matcher: h.matcher,
-                description: h.description,
-              })),
+              {
+                hooks: hooks.map((h) => ({
+                  id: h.id,
+                  event: h.event,
+                  name: h.name,
+                  type: h.type,
+                  priority: h.priority,
+                  enabled: h.enabled === 1,
+                  matcher: h.matcher,
+                  description: h.description,
+                })),
+                settingsHooks,
+                settingsFiles,
+              },
               null,
               2,
             ),
           );
-        } else if (hooks.length === 0) {
-          logger.info(
-            'No hooks registered. Add one with "chainlesschain hook add <event> <name>"',
-          );
         } else {
-          logger.log(chalk.bold(`Hooks (${hooks.length}):\n`));
-          for (const h of hooks) {
-            const status = h.enabled
-              ? chalk.green("enabled")
-              : chalk.gray("disabled");
-            const pLabel = Object.entries(HookPriority).find(
-              ([, v]) => v === h.priority,
+          if (hooks.length === 0) {
+            logger.info(
+              'No DB hooks. Add one with "chainlesschain hook add <event> <name>"',
             );
-            const priorityStr = pLabel ? pLabel[0] : String(h.priority);
-            logger.log(
-              `  ${chalk.cyan(h.name)} [${h.event}] priority=${priorityStr} type=${h.type} [${status}]`,
+          } else {
+            logger.log(chalk.bold(`DB hooks (${hooks.length}):\n`));
+            for (const h of hooks) {
+              const status = h.enabled
+                ? chalk.green("enabled")
+                : chalk.gray("disabled");
+              const pLabel = Object.entries(HookPriority).find(
+                ([, v]) => v === h.priority,
+              );
+              const priorityStr = pLabel ? pLabel[0] : String(h.priority);
+              logger.log(
+                `  ${chalk.cyan(h.name)} [${h.event}] priority=${priorityStr} type=${h.type} [${status}]`,
+              );
+              if (h.description) logger.log(`    ${chalk.gray(h.description)}`);
+              if (h.matcher)
+                logger.log(`    matcher: ${chalk.yellow(h.matcher)}`);
+            }
+          }
+          const events = Object.keys(settingsHooks);
+          if (events.length > 0) {
+            const n = events.reduce(
+              (a, e) => a + settingsHooks[e].length,
+              0,
             );
-            if (h.description) logger.log(`    ${chalk.gray(h.description)}`);
-            if (h.matcher)
-              logger.log(`    matcher: ${chalk.yellow(h.matcher)}`);
+            logger.log(chalk.bold(`\n.claude/settings.json hooks (${n}):`));
+            for (const ev of events) {
+              if (options.event && ev !== options.event) continue;
+              for (const g of settingsHooks[ev]) {
+                for (const h of g.hooks) {
+                  logger.log(
+                    `  ${chalk.cyan(ev)} matcher=${chalk.yellow(g.matcher || "*")}  ${chalk.gray(h.command)}`,
+                  );
+                }
+              }
+            }
+            logger.log(chalk.dim(`  sources: ${settingsFiles.join(", ")}`));
           }
         }
 
@@ -93,6 +127,80 @@ export function registerHookCommand(program) {
       }
     });
 
+  // hook test — dry-run .claude/settings.json hooks for an event + tool
+  hook
+    .command("test <event> <tool> [args...]")
+    .description(
+      'Show which settings.json hooks fire for an event+tool (e.g. hook test PreToolUse run_shell "git push"); --run executes them',
+    )
+    .option("--settings <file>", "Also merge an explicit settings file")
+    .option("--run", "Actually execute the matched hooks and show decisions")
+    .option("--json", "Output as JSON")
+    .action(async (event, tool, args, options) => {
+      try {
+        const { loadHooks, collectHooks } =
+          await import("../lib/settings-hooks.cjs");
+        const { hooks } = loadHooks({
+          cwd: process.cwd(),
+          settingsFile: options.settings,
+        });
+        const matched = collectHooks(hooks, event, tool);
+        const toolInput = args && args.length ? { command: args.join(" "), args } : {};
+        const payload = {
+          hook_event_name: event,
+          tool_name: tool,
+          tool_input: toolInput,
+          cwd: process.cwd(),
+          session_id: "test",
+        };
+
+        if (!options.run) {
+          if (options.json) {
+            console.log(JSON.stringify({ event, tool, matched, payload }, null, 2));
+          } else if (matched.length === 0) {
+            logger.log(
+              chalk.gray(`no settings.json hooks match ${event} / ${tool}`),
+            );
+          } else {
+            logger.log(
+              chalk.bold(`${matched.length} hook(s) would fire for ${event} / ${tool}:`),
+            );
+            for (const h of matched) logger.log(`  ${chalk.gray(h.command)}`);
+            logger.log(chalk.dim("  (use --run to execute and see decisions)"));
+          }
+          return;
+        }
+
+        const { runHooks } = await import("../lib/hook-runner.cjs");
+        const outcome = runHooks(matched, payload, {
+          cwd: process.cwd(),
+          event,
+        });
+        if (options.json) {
+          console.log(JSON.stringify(outcome, null, 2));
+          return;
+        }
+        const color =
+          outcome.decision === "block"
+            ? chalk.red
+            : outcome.decision === "ask"
+              ? chalk.yellow
+              : chalk.green;
+        logger.log(`decision: ${color.bold(outcome.decision)}`);
+        if (outcome.reason) logger.log(`reason:   ${outcome.reason}`);
+        if (outcome.hook) logger.log(`from:     ${chalk.gray(outcome.hook)}`);
+        for (const r of outcome.results) {
+          logger.log(
+            `  ${chalk.gray(r.command)} → ${r.decision}` +
+              (r.exitCode != null ? ` (exit ${r.exitCode})` : ""),
+          );
+        }
+      } catch (err) {
+        logger.error(`hook test failed: ${err.message}`);
+        process.exitCode = 1;
+      }
+    });
+
   // hook add
   hook
     .command("add")

package/src/commands/ide.js

@@ -0,0 +1,168 @@
+/**
+ * `cc ide` — inspect IDE bridge discovery (Phase 0).
+ *
+ * The agent auto-connects a running editor's MCP server when inside an IDE
+ * integrated terminal (or with `cc agent --ide`). These subcommands make that
+ * discovery visible and debuggable WITHOUT running an agent:
+ *
+ *   cc ide list             list live IDE lockfiles found
+ *   cc ide status           which server `cc agent` would connect to (+ its MCP config)
+ *   cc ide doctor           explain WHY discovery did / didn't pick a server
+ *
+ * Pure read-only over ~/.chainlesschain/ide/*.json — see
+ * docs/design/modules/98_IDE桥接对标方案.md.
+ */
+import chalk from "chalk";
+import {
+  readIdeLocks,
+  discoverIdeServer,
+  ideServerToMcpConfig,
+  isInIdeTerminal,
+  ideLockDir,
+  diagnoseIde,
+} from "../lib/ide-bridge.js";
+
+function emit(obj) {
+  console.log(JSON.stringify(obj, null, 2));
+}
+
+export function registerIdeCommand(program) {
+  const ide = program
+    .command("ide")
+    .description("Inspect IDE bridge discovery (editor MCP server auto-connect)");
+
+  ide
+    .command("list")
+    .description("List live IDE lockfiles (editor MCP servers advertised)")
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const locks = readIdeLocks();
+      if (options.json) {
+        // Never surface the raw bearer token or internal _file path.
+        const safe = locks.map(({ token, _file, ...rest }) => ({
+          ...rest,
+          hasToken: !!token,
+        }));
+        emit({ lockDir: ideLockDir(), count: safe.length, locks: safe });
+        return;
+      }
+      if (!locks.length) {
+        console.log(
+          chalk.gray(`No live IDE lockfiles in ${ideLockDir()}`),
+        );
+        console.log(
+          chalk.gray(
+            "Start an IDE extension that advertises one, or run `cc ide doctor`.",
+          ),
+        );
+        return;
+      }
+      console.log(chalk.bold(`IDE servers (${locks.length}) in ${ideLockDir()}:`));
+      for (const l of locks) {
+        console.log(
+          `  ${chalk.cyan(l.ide)}  port ${l.port}  ${l.transport}  ` +
+            `${l.token ? chalk.green("token") : chalk.yellow("no-token")}`,
+        );
+        console.log(chalk.gray(`    url ${l.url}`));
+        if (l.workspaceFolders.length) {
+          console.log(chalk.gray(`    ws  ${l.workspaceFolders.join(", ")}`));
+        }
+      }
+    });
+
+  ide
+    .command("status")
+    .description("Show the IDE server `cc agent` would connect to right now")
+    .option("--ide", "Force selection even outside an IDE terminal")
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const env = process.env;
+      const cwd = process.cwd();
+      const inIde = isInIdeTerminal(env);
+      const lock = discoverIdeServer({ cwd, env, force: options.ide === true });
+      const cfg = lock ? ideServerToMcpConfig(lock) : null;
+      // Redact the bearer token in the previewed config.
+      const safeCfg = cfg
+        ? {
+            ...cfg,
+            headers: cfg.headers?.Authorization
+              ? { ...cfg.headers, Authorization: "Bearer ***" }
+              : cfg.headers,
+          }
+        : null;
+      if (options.json) {
+        // Strip the raw token + internal _file from the chosen lock.
+        const safeChosen = lock
+          ? (({ token, _file, ...rest }) => ({ ...rest, hasToken: !!token }))(
+              lock,
+            )
+          : null;
+        emit({
+          inIdeTerminal: inIde,
+          chosen: safeChosen,
+          mcpConfig: safeCfg,
+        });
+        return;
+      }
+      console.log(
+        `In IDE terminal: ${inIde ? chalk.green("yes") : chalk.gray("no")}`,
+      );
+      if (!lock) {
+        console.log(
+          chalk.gray(
+            "No IDE server would be connected. Try `cc ide doctor` for why.",
+          ),
+        );
+        return;
+      }
+      console.log(
+        `Would connect: ${chalk.cyan(lock.ide)} on port ${lock.port} ` +
+          `(${lock.transport}) as MCP server ${chalk.bold("ide")}`,
+      );
+      console.log(chalk.gray("MCP config:"));
+      console.log(chalk.gray("  " + JSON.stringify(safeCfg)));
+    });
+
+  ide
+    .command("doctor")
+    .description("Explain why IDE discovery did / didn't pick a server")
+    .option("--ide", "Diagnose as if --ide (force) were passed")
+    .option("--json", "Machine-readable output")
+    .action((options) => {
+      const diag = diagnoseIde({
+        cwd: process.cwd(),
+        env: process.env,
+        force: options.ide === true,
+      });
+      if (options.json) {
+        emit(diag);
+        return;
+      }
+      console.log(chalk.bold("IDE bridge discovery"));
+      console.log(`  lock dir       : ${diag.lockDir}`);
+      console.log(
+        `  in IDE terminal: ${diag.inIdeTerminal ? chalk.green("yes") : chalk.gray("no")}`,
+      );
+      console.log(`  live locks     : ${diag.locks.length}`);
+      for (const l of diag.locks) {
+        const m =
+          l.matchScore >= 0
+            ? chalk.green(`workspace-match(${l.matchScore})`)
+            : chalk.yellow("no-workspace-match");
+        console.log(
+          `    - ${chalk.cyan(l.ide)} port ${l.port} ${l.transport} ` +
+            `${l.hasToken ? "token" : chalk.yellow("no-token")} ${m}`,
+        );
+      }
+      console.log(
+        `  result         : ${
+          diag.chosen
+            ? chalk.green(`connect ${diag.chosen.ide}:${diag.chosen.port}`)
+            : chalk.yellow("nothing to connect")
+        }`,
+      );
+      console.log(`  reason         : ${diag.reason}`);
+    });
+
+  return ide;
+}