chainlesschain 0.45.70 → 0.45.74

package/src/runtime/coding-agent-contract.js

@@ -1,193 +1,18 @@
 import { ToolRegistry, createDefaultToolRegistry } from "../tools/registry.js";
-import sharedCodingAgentPolicy from "./coding-agent-policy.cjs";
+import sharedContract from "./coding-agent-contract-shared.cjs";
+
+const {
+  CODING_AGENT_EXTENSION_TOOL_NAMES,
+  CODING_AGENT_MVP_TOOL_NAMES,
+  getCodingAgentFunctionToolDefinition,
+  getCodingAgentFunctionToolDefinitions,
+  getCodingAgentToolContract,
+  getCodingAgentToolContracts,
+  getCodingAgentToolPolicy,
+  isCodingAgentMvpTool,
+  listCodingAgentToolNames,
+} = sharedContract;
 
-const { TOOL_POLICY_METADATA } = sharedCodingAgentPolicy;
-
-const CODING_AGENT_TOOL_CONTRACTS = Object.freeze([
-  {
-    name: "read_file",
-    title: "Read File",
-    kind: "filesystem",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.read_file,
-    permissions: {
-      level: "readonly",
-      scopes: ["filesystem:read"],
-    },
-    telemetry: {
-      category: "filesystem",
-      tags: ["tool:read_file", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "write_file",
-    title: "Write File",
-    kind: "filesystem",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.write_file,
-    permissions: {
-      level: "elevated",
-      scopes: ["filesystem:write"],
-    },
-    telemetry: {
-      category: "filesystem",
-      tags: ["tool:write_file", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "edit_file",
-    title: "Edit File",
-    kind: "filesystem",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.edit_file,
-    permissions: {
-      level: "elevated",
-      scopes: ["filesystem:write"],
-    },
-    telemetry: {
-      category: "filesystem",
-      tags: ["tool:edit_file", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "run_shell",
-    title: "Run Shell",
-    kind: "shell",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.run_shell,
-    runtimeDescriptor: "shell",
-    permissions: {
-      level: "elevated",
-      scopes: ["process:spawn", "filesystem:workspace"],
-    },
-    telemetry: {
-      category: "shell",
-      tags: ["tool:run_shell", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "git",
-    title: "Git",
-    kind: "git",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.git,
-    runtimeDescriptor: "git",
-    permissions: {
-      level: "elevated",
-      scopes: ["process:spawn", "filesystem:workspace", "vcs:git"],
-    },
-    telemetry: {
-      category: "git",
-      tags: ["tool:git", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "search_files",
-    title: "Search Files",
-    kind: "filesystem",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.search_files,
-    permissions: {
-      level: "readonly",
-      scopes: ["filesystem:read", "search:content"],
-    },
-    telemetry: {
-      category: "filesystem",
-      tags: ["tool:search_files", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "list_dir",
-    title: "List Directory",
-    kind: "filesystem",
-    tier: "mvp",
-    ...TOOL_POLICY_METADATA.list_dir,
-    permissions: {
-      level: "readonly",
-      scopes: ["filesystem:read"],
-    },
-    telemetry: {
-      category: "filesystem",
-      tags: ["tool:list_dir", "contract:coding-agent", "tier:mvp"],
-    },
-  },
-  {
-    name: "run_skill",
-    title: "Run Skill",
-    kind: "skill",
-    tier: "extension",
-    ...TOOL_POLICY_METADATA.run_skill,
-    permissions: {
-      level: "standard",
-      scopes: ["skill:invoke"],
-    },
-    telemetry: {
-      category: "skill",
-      tags: ["tool:run_skill", "contract:coding-agent", "tier:extension"],
-    },
-  },
-  {
-    name: "list_skills",
-    title: "List Skills",
-    kind: "skill",
-    tier: "extension",
-    ...TOOL_POLICY_METADATA.list_skills,
-    permissions: {
-      level: "readonly",
-      scopes: ["skill:read"],
-    },
-    telemetry: {
-      category: "skill",
-      tags: ["tool:list_skills", "contract:coding-agent", "tier:extension"],
-    },
-  },
-  {
-    name: "run_code",
-    title: "Run Code",
-    kind: "code",
-    tier: "extension",
-    ...TOOL_POLICY_METADATA.run_code,
-    permissions: {
-      level: "elevated",
-      scopes: ["process:spawn", "filesystem:workspace", "runtime:script"],
-    },
-    telemetry: {
-      category: "code",
-      tags: ["tool:run_code", "contract:coding-agent", "tier:extension"],
-    },
-  },
-  {
-    name: "spawn_sub_agent",
-    title: "Spawn Sub Agent",
-    kind: "agent",
-    tier: "extension",
-    ...TOOL_POLICY_METADATA.spawn_sub_agent,
-    permissions: {
-      level: "elevated",
-      scopes: ["agent:spawn"],
-    },
-    telemetry: {
-      category: "agent",
-      tags: ["tool:spawn_sub_agent", "contract:coding-agent", "tier:extension"],
-    },
-  },
-]);
-
-export const CODING_AGENT_MVP_TOOL_NAMES = Object.freeze(
-  CODING_AGENT_TOOL_CONTRACTS.filter((tool) => tool.tier === "mvp").map(
-    (tool) => tool.name,
-  ),
-);
-
-export const CODING_AGENT_EXTENSION_TOOL_NAMES = Object.freeze(
-  CODING_AGENT_TOOL_CONTRACTS.filter((tool) => tool.tier === "extension").map(
-    (tool) => tool.name,
-  ),
-);
-
-const TOOL_CONTRACT_MAP = new Map(
-  CODING_AGENT_TOOL_CONTRACTS.map((tool) => [tool.name, tool]),
-);
 const runtimeRegistry = createDefaultToolRegistry();
 
 function cloneValue(value) {
@@ -216,44 +41,17 @@ function getFallbackToolContract(name) {
   };
 }
 
-export function getCodingAgentToolContract(name) {
-  const tool = TOOL_CONTRACT_MAP.get(name);
-  return tool ? cloneValue(tool) : null;
-}
-
-export function getCodingAgentToolContracts({ tier = null } = {}) {
-  return CODING_AGENT_TOOL_CONTRACTS.filter((tool) => {
-    if (tier && tool.tier !== tier) {
-      return false;
-    }
-    return true;
-  }).map(cloneValue);
-}
-
-export function listCodingAgentToolNames({ tier = null } = {}) {
-  return getCodingAgentToolContracts({ tier }).map((tool) => tool.name);
-}
-
-export function isCodingAgentMvpTool(name) {
-  return CODING_AGENT_MVP_TOOL_NAMES.includes(name);
-}
-
-export function getCodingAgentToolPolicy(name) {
-  const tool = TOOL_CONTRACT_MAP.get(name);
-  if (!tool) {
-    return null;
-  }
-
-  return {
-    tier: tool.tier,
-    riskLevel: tool.riskLevel,
-    availableInPlanMode: tool.availableInPlanMode,
-    planModeBehavior: tool.planModeBehavior || "standard",
-    requiresPlanApproval: tool.requiresPlanApproval,
-    approvalFlow: tool.approvalFlow,
-    permissions: cloneValue(tool.permissions),
-  };
-}
+export {
+  CODING_AGENT_EXTENSION_TOOL_NAMES,
+  CODING_AGENT_MVP_TOOL_NAMES,
+  getCodingAgentFunctionToolDefinition,
+  getCodingAgentFunctionToolDefinitions,
+  getCodingAgentToolContract,
+  getCodingAgentToolContracts,
+  getCodingAgentToolPolicy,
+  isCodingAgentMvpTool,
+  listCodingAgentToolNames,
+};
 
 export function mapCodingAgentToolDefinition(definition = {}, options = {}) {
   const fn = definition.function || {};
@@ -269,8 +67,14 @@ export function mapCodingAgentToolDefinition(definition = {}, options = {}) {
     name,
     title: contract.title || name,
     kind: contract.kind,
-    description: fn.description || "",
-    schema: fn.parameters || { type: "object", properties: {} },
+    description: fn.description || contract.description || "",
+    schema: fn.parameters ||
+      (contract.inputSchema
+        ? cloneValue(contract.inputSchema)
+        : {
+            type: "object",
+            properties: {},
+          }),
     permissions: cloneValue(contract.permissions),
     telemetry: cloneValue(contract.telemetry),
     source: options.source || "agent-core",
@@ -286,9 +90,25 @@ export function createCodingAgentToolRegistry(definitions = [], options = {}) {
 }
 
 export function getCodingAgentRuntimeDescriptor(toolName) {
-  const descriptorName = TOOL_CONTRACT_MAP.get(toolName)?.runtimeDescriptor;
+  const descriptorName = getCodingAgentToolContract(toolName)?.runtimeDescriptor;
   if (!descriptorName) {
     return null;
   }
   return runtimeRegistry.get(descriptorName) || null;
 }
+
+export function getCodingAgentRuntimeDescriptorByCommand(command) {
+  const trimmed = String(command || "").trim();
+  if (!trimmed) {
+    return null;
+  }
+
+  const parts = trimmed.split(/\s+/);
+  if (parts[0] === "git") {
+    return runtimeRegistry.get("git") || null;
+  }
+  if (parts[0] === "mcp" || parts.includes("mcp")) {
+    return runtimeRegistry.get("mcp") || null;
+  }
+  return runtimeRegistry.get("shell") || null;
+}

package/src/runtime/coding-agent-policy.cjs

@@ -74,6 +74,16 @@ const TOOL_POLICY_METADATA = Object.freeze({
     approvalFlow: "plan",
     isReadOnly: false,
   },
+  edit_file_hashed: {
+    riskLevel: RISK_LEVELS.MEDIUM,
+    category: TOOL_CATEGORIES.WRITE,
+    availableInPlanMode: false,
+    planModeBehavior: "blocked",
+    requiresPlanApproval: true,
+    requiresConfirmation: false,
+    approvalFlow: "plan",
+    isReadOnly: false,
+  },
   write_file: {
     riskLevel: RISK_LEVELS.MEDIUM,
     category: TOOL_CATEGORIES.WRITE,
@@ -193,14 +203,53 @@ function resolveToolPolicy(toolName, descriptor = null) {
     base.riskLevel = normalizeRiskLevel(descriptor.riskLevel, base.riskLevel);
   }
 
+  if (descriptor?.category) {
+    base.category = descriptor.category;
+  }
+
+  if (typeof descriptor?.availableInPlanMode === "boolean") {
+    base.availableInPlanMode = descriptor.availableInPlanMode;
+  }
+
+  if (descriptor?.planModeBehavior) {
+    base.planModeBehavior = descriptor.planModeBehavior;
+  }
+
+  if (typeof descriptor?.requiresPlanApproval === "boolean") {
+    base.requiresPlanApproval = descriptor.requiresPlanApproval;
+  }
+
+  if (typeof descriptor?.requiresConfirmation === "boolean") {
+    base.requiresConfirmation = descriptor.requiresConfirmation;
+  }
+
+  if (descriptor?.approvalFlow) {
+    base.approvalFlow = descriptor.approvalFlow;
+  }
+
+  if (Array.isArray(descriptor?.readOnlySubcommands)) {
+    base.readOnlySubcommands = [...descriptor.readOnlySubcommands];
+  }
+
   if (descriptor?.isReadOnly === true) {
     base.isReadOnly = true;
     base.riskLevel = RISK_LEVELS.LOW;
-    base.availableInPlanMode = true;
-    base.planModeBehavior = "allow";
-    base.requiresPlanApproval = false;
-    base.requiresConfirmation = false;
-    base.approvalFlow = "auto";
+    base.category = descriptor?.category || TOOL_CATEGORIES.READ;
+    if (typeof descriptor?.availableInPlanMode !== "boolean") {
+      base.availableInPlanMode = true;
+    }
+    if (!descriptor?.planModeBehavior) {
+      base.planModeBehavior = "allow";
+    }
+    if (typeof descriptor?.requiresPlanApproval !== "boolean") {
+      base.requiresPlanApproval = false;
+    }
+    if (typeof descriptor?.requiresConfirmation !== "boolean") {
+      base.requiresConfirmation = false;
+    }
+    if (!descriptor?.approvalFlow) {
+      base.approvalFlow = "auto";
+    }
   }
 
   return base;

package/src/runtime/diagnostics.js

@@ -0,0 +1,317 @@
+/**
+ * Runtime diagnostics — machine-readable doctor/status reports.
+ *
+ * Canonical data collectors for `chainlesschain doctor` and
+ * `chainlesschain status`. These return plain JSON-serializable
+ * objects that both the human-readable CLI renderers and external
+ * consumers (IDE integrations, monitoring) can rely on.
+ *
+ * Introduced as part of the CLI Runtime Convergence roadmap (Phase 5,
+ * 2026-04-09) per ADR decision D6 (machine-readable doctor/status JSON).
+ *
+ * Refs: docs/implementation-plans/CLI_RUNTIME_CONVERGENCE_ADR.md
+ */
+
+import { execSync } from "node:child_process";
+import { existsSync, readdirSync } from "node:fs";
+import { createConnection } from "node:net";
+import semver from "semver";
+
+import { MIN_NODE_VERSION, DEFAULT_PORTS, VERSION } from "../constants.js";
+import { getHomeDir, getConfigPath, getBinDir } from "../lib/paths.js";
+import {
+  isDockerAvailable,
+  isDockerComposeAvailable,
+  getServiceStatus,
+  findComposeFile,
+} from "../lib/service-manager.js";
+import { loadConfig } from "../lib/config-manager.js";
+import { isAppRunning, getAppPid } from "../lib/process-manager.js";
+
+/**
+ * Probe a TCP port. Resolves true if something is listening.
+ */
+export function checkPort(port, host = "127.0.0.1", timeoutMs = 1000) {
+  return new Promise((resolve) => {
+    const socket = createConnection({ port, host, timeout: timeoutMs });
+    socket.on("connect", () => {
+      socket.destroy();
+      resolve(true);
+    });
+    socket.on("error", () => resolve(false));
+    socket.on("timeout", () => {
+      socket.destroy();
+      resolve(false);
+    });
+  });
+}
+
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
+  }
+}
+
+function safeExec(cmd) {
+  try {
+    return execSync(cmd, { encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Collect a machine-readable doctor report.
+ *
+ * Shape:
+ * {
+ *   schema: "chainlesschain.doctor.v1",
+ *   version: string,         // CLI version
+ *   generatedAt: string,     // ISO timestamp
+ *   checks: Array<{ id, name, ok, optional, detail }>,
+ *   ports: Array<{ name, port, open }>,
+ *   disk: { homeDir, freeGB } | null,
+ *   summary: { total, passed, failed, criticalFailed }
+ * }
+ */
+export async function collectDoctorReport() {
+  const checks = [];
+
+  // Node.js
+  const nodeVersion = process.versions.node;
+  const nodeOk = semver.gte(nodeVersion, MIN_NODE_VERSION);
+  checks.push({
+    id: "node",
+    name: `Node.js ${nodeVersion}`,
+    ok: nodeOk,
+    optional: false,
+    detail: nodeOk ? "" : `Requires >=${MIN_NODE_VERSION}`,
+  });
+
+  // npm
+  const npmVersion = safeExec("npm --version");
+  checks.push({
+    id: "npm",
+    name: npmVersion ? `npm ${npmVersion}` : "npm",
+    ok: Boolean(npmVersion),
+    optional: false,
+    detail: npmVersion ? "" : "Not found",
+  });
+
+  // Docker
+  const dockerOk = isDockerAvailable();
+  checks.push({
+    id: "docker",
+    name: "Docker",
+    ok: dockerOk,
+    optional: true,
+    detail: dockerOk ? "" : "Not installed (optional)",
+  });
+
+  const composeOk = isDockerComposeAvailable();
+  checks.push({
+    id: "docker-compose",
+    name: "Docker Compose",
+    ok: composeOk,
+    optional: true,
+    detail: composeOk ? "" : "Not installed (optional)",
+  });
+
+  // Git
+  const gitVersion = safeExec("git --version");
+  checks.push({
+    id: "git",
+    name: gitVersion || "Git",
+    ok: Boolean(gitVersion),
+    optional: false,
+    detail: gitVersion ? "" : "Not found",
+  });
+
+  // Config directory
+  const homeDir = getHomeDir();
+  const homeOk = existsSync(homeDir);
+  checks.push({
+    id: "config-dir",
+    name: `Config dir: ${homeDir}`,
+    ok: homeOk,
+    optional: false,
+    detail: homeOk ? "" : 'Run "chainlesschain setup"',
+  });
+
+  // Config file
+  const configPath = getConfigPath();
+  const configOk = existsSync(configPath);
+  checks.push({
+    id: "config-file",
+    name: "Config file",
+    ok: configOk,
+    optional: false,
+    detail: configOk ? "" : 'Run "chainlesschain setup"',
+  });
+
+  // Desktop binary
+  const binDir = getBinDir();
+  const hasBin = existsSync(binDir) && readdirSafe(binDir).length > 0;
+  checks.push({
+    id: "desktop-binary",
+    name: "Desktop binary",
+    ok: hasBin,
+    optional: true,
+    detail: hasBin
+      ? ""
+      : 'Run "chainlesschain setup" or "chainlesschain update"',
+  });
+
+  // Setup completed
+  let setupCompleted = false;
+  try {
+    setupCompleted = Boolean(loadConfig().setupCompleted);
+  } catch {
+    // loadConfig may throw if config missing
+  }
+  checks.push({
+    id: "setup-completed",
+    name: "Setup completed",
+    ok: setupCompleted,
+    optional: false,
+    detail: setupCompleted ? "" : 'Run "chainlesschain setup"',
+  });
+
+  // Port scan
+  const ports = [];
+  for (const [name, port] of Object.entries(DEFAULT_PORTS)) {
+    const open = await checkPort(port);
+    ports.push({ name, port, open });
+  }
+
+  // Disk (Node 22+ statfsSync)
+  let disk = null;
+  try {
+    const { statfsSync } = await import("node:fs");
+    if (typeof statfsSync === "function") {
+      const stats = statfsSync(homeDir);
+      const freeGB = (stats.bavail * stats.bsize) / (1024 * 1024 * 1024);
+      disk = { homeDir, freeGB: Number(freeGB.toFixed(2)) };
+    }
+  } catch {
+    // statfsSync unavailable on some platforms
+  }
+
+  const failed = checks.filter((c) => !c.ok);
+  const criticalFailed = failed.filter((c) => !c.optional);
+
+  return {
+    schema: "chainlesschain.doctor.v1",
+    version: VERSION,
+    generatedAt: new Date().toISOString(),
+    checks,
+    ports,
+    disk,
+    summary: {
+      total: checks.length,
+      passed: checks.length - failed.length,
+      failed: failed.length,
+      criticalFailed: criticalFailed.length,
+    },
+  };
+}
+
+/**
+ * Collect a machine-readable status report.
+ *
+ * Shape:
+ * {
+ *   schema: "chainlesschain.status.v1",
+ *   version: string,
+ *   generatedAt: string,
+ *   app: { running, pid },
+ *   setup: { completed, completedAt, edition, llm: { provider, model } } | null,
+ *   docker: {
+ *     available,
+ *     composePath: string | null,
+ *     services: Array<{ name, state }> | null,
+ *     note: string | null
+ *   },
+ *   ports: Array<{ name, port, open }>
+ * }
+ */
+export async function collectStatusReport() {
+  let config = {};
+  try {
+    config = loadConfig();
+  } catch {
+    // loadConfig may throw if config missing
+  }
+
+  // App
+  const running = isAppRunning();
+  const app = {
+    running,
+    pid: running ? getAppPid() : null,
+  };
+
+  // Setup
+  const setup = config.setupCompleted
+    ? {
+        completed: true,
+        completedAt: config.completedAt || null,
+        edition: config.edition || null,
+        llm: config.llm
+          ? {
+              provider: config.llm.provider || null,
+              model: config.llm.model || null,
+            }
+          : null,
+      }
+    : { completed: false };
+
+  // Docker services
+  const dockerAvailable = isDockerAvailable();
+  const docker = {
+    available: dockerAvailable,
+    composePath: null,
+    services: null,
+    note: null,
+  };
+
+  if (!dockerAvailable) {
+    docker.note = "Docker not available";
+  } else {
+    const composePath = findComposeFile([process.cwd(), "backend/docker"]);
+    if (!composePath) {
+      docker.note = "docker-compose.yml not found";
+    } else {
+      docker.composePath = composePath;
+      const raw = getServiceStatus(composePath);
+      if (Array.isArray(raw)) {
+        docker.services = raw.map((svc) => ({
+          name: svc.Service || svc.Name || null,
+          state: svc.State || null,
+        }));
+      } else if (raw) {
+        docker.note = String(raw);
+      } else {
+        docker.note = "No services running";
+      }
+    }
+  }
+
+  // Ports
+  const ports = [];
+  for (const [name, port] of Object.entries(DEFAULT_PORTS)) {
+    const open = await checkPort(port);
+    ports.push({ name, port, open });
+  }
+
+  return {
+    schema: "chainlesschain.status.v1",
+    version: VERSION,
+    generatedAt: new Date().toISOString(),
+    app,
+    setup,
+    docker,
+    ports,
+  };
+}

package/src/runtime/index.js

@@ -15,7 +15,10 @@ export {
   CODING_AGENT_MVP_TOOL_NAMES,
   CODING_AGENT_EXTENSION_TOOL_NAMES,
   createCodingAgentToolRegistry,
+  getCodingAgentFunctionToolDefinition,
+  getCodingAgentFunctionToolDefinitions,
   getCodingAgentRuntimeDescriptor,
+  getCodingAgentRuntimeDescriptorByCommand,
   getCodingAgentToolContract,
   getCodingAgentToolContracts,
   getCodingAgentToolPolicy,