@nimiplatform/nimi-coding 0.1.0

package/cli/commands/closeout.mjs

@@ -0,0 +1,183 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import {
+  buildCloseoutPayload,
+  formatCloseoutPayload,
+  loadImportedCloseoutOptions,
+} from "../lib/shared.mjs";
+import { localize } from "../lib/ui.mjs";
+
+function parseCloseoutOptions(args) {
+  const options = {
+    json: false,
+    writeLocal: false,
+    fromPath: null,
+    skill: null,
+    outcome: null,
+    verifiedAt: null,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--write-local") {
+      options.writeLocal = true;
+      continue;
+    }
+
+    if (arg === "--skill" || arg === "--outcome" || arg === "--verified-at" || arg === "--from") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        return {
+          ok: false,
+          error: `${localize(
+            `nimicoding closeout refused: ${arg} requires a value.`,
+            `nimicoding closeout 已拒绝：${arg} 需要一个值。`,
+          )}\n`,
+        };
+      }
+
+      if (arg === "--skill") {
+        options.skill = next;
+      } else if (arg === "--outcome") {
+        options.outcome = next;
+      } else if (arg === "--from") {
+        options.fromPath = next;
+      } else {
+        options.verifiedAt = next;
+      }
+      index += 1;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding closeout refused: unknown option ${arg}.`,
+        `nimicoding closeout 已拒绝：未知选项 ${arg}。`,
+      )}\n`,
+    };
+  }
+
+  if (options.fromPath && (options.skill || options.outcome || options.verifiedAt)) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding closeout refused: --from cannot be combined with --skill, --outcome, or --verified-at.",
+        "nimicoding closeout 已拒绝：`--from` 不能与 `--skill`、`--outcome` 或 `--verified-at` 同时使用。",
+      )}\n`,
+    };
+  }
+
+  if (options.fromPath) {
+    return {
+      ok: true,
+      options,
+    };
+  }
+
+  if (!options.skill) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding closeout refused: explicit --skill is required.",
+        "nimicoding closeout 已拒绝：必须显式提供 `--skill`。",
+      )}\n`,
+    };
+  }
+
+  if (!options.outcome) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding closeout refused: explicit --outcome is required.",
+        "nimicoding closeout 已拒绝：必须显式提供 `--outcome`。",
+      )}\n`,
+    };
+  }
+
+  if (!["completed", "blocked", "failed"].includes(options.outcome)) {
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding closeout refused: unsupported outcome ${options.outcome}.`,
+        `nimicoding closeout 已拒绝：不支持的 outcome ${options.outcome}。`,
+      )}\n`,
+    };
+  }
+
+  if (!options.verifiedAt) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding closeout refused: explicit --verified-at is required.",
+        "nimicoding closeout 已拒绝：必须显式提供 `--verified-at`。",
+      )}\n`,
+    };
+  }
+
+  const verifiedDate = new Date(options.verifiedAt);
+  if (Number.isNaN(verifiedDate.getTime()) || verifiedDate.toISOString() !== options.verifiedAt) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding closeout refused: --verified-at must be an ISO-8601 UTC timestamp.",
+        "nimicoding closeout 已拒绝：`--verified-at` 必须是 ISO-8601 UTC 时间戳。",
+      )}\n`,
+    };
+  }
+
+  return {
+    ok: true,
+    options,
+  };
+}
+
+export async function runCloseout(args) {
+  const parsed = parseCloseoutOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  let effectiveOptions = parsed.options;
+  if (parsed.options.fromPath) {
+    const imported = await loadImportedCloseoutOptions(process.cwd(), parsed.options.fromPath);
+    if (!imported.ok) {
+      process.stderr.write(imported.error);
+      return 2;
+    }
+
+    effectiveOptions = {
+      ...parsed.options,
+      ...imported.options,
+    };
+  }
+
+  const payload = await buildCloseoutPayload(process.cwd(), effectiveOptions);
+  if (payload.inputError) {
+    process.stderr.write(payload.error);
+    return payload.exitCode;
+  }
+
+  if (payload.ok && parsed.options.writeLocal) {
+    await mkdir(path.dirname(payload.artifactPath), { recursive: true });
+    await writeFile(payload.artifactPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  }
+
+  if (parsed.options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write(formatCloseoutPayload(payload));
+  }
+
+  return payload.exitCode;
+}
+
+export { parseCloseoutOptions };

package/cli/commands/decide-high-risk-execution.mjs

@@ -0,0 +1,124 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import {
+  buildHighRiskDecisionPayload,
+  formatHighRiskDecisionPayload,
+} from "../lib/high-risk-decision.mjs";
+import { localize } from "../lib/ui.mjs";
+
+function parseDecideHighRiskExecutionOptions(args) {
+  const options = {
+    fromPath: null,
+    acceptancePath: null,
+    verifiedAt: null,
+    json: false,
+    writeLocal: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--write-local") {
+      options.writeLocal = true;
+      continue;
+    }
+
+    if (arg === "--from" || arg === "--acceptance" || arg === "--verified-at") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        return {
+          ok: false,
+          error: `${localize(
+            `nimicoding decide-high-risk-execution refused: ${arg} requires a value.`,
+            `nimicoding decide-high-risk-execution 已拒绝：${arg} 需要一个值。`,
+          )}\n`,
+        };
+      }
+
+      if (arg === "--from") {
+        options.fromPath = next;
+      } else if (arg === "--acceptance") {
+        options.acceptancePath = next;
+      } else {
+        options.verifiedAt = next;
+      }
+      index += 1;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding decide-high-risk-execution refused: unknown option ${arg}.`,
+        `nimicoding decide-high-risk-execution 已拒绝：未知选项 ${arg}。`,
+      )}\n`,
+    };
+  }
+
+  if (!options.fromPath) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding decide-high-risk-execution refused: explicit --from is required.",
+        "nimicoding decide-high-risk-execution 已拒绝：必须显式提供 `--from`。",
+      )}\n`,
+    };
+  }
+
+  if (!options.acceptancePath) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding decide-high-risk-execution refused: explicit --acceptance is required.",
+        "nimicoding decide-high-risk-execution 已拒绝：必须显式提供 `--acceptance`。",
+      )}\n`,
+    };
+  }
+
+  if (!options.verifiedAt) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding decide-high-risk-execution refused: explicit --verified-at is required.",
+        "nimicoding decide-high-risk-execution 已拒绝：必须显式提供 `--verified-at`。",
+      )}\n`,
+    };
+  }
+
+  return { ok: true, options };
+}
+
+export async function runDecideHighRiskExecution(args) {
+  const parsed = parseDecideHighRiskExecutionOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  const payload = await buildHighRiskDecisionPayload(process.cwd(), parsed.options);
+  if (payload.inputError) {
+    process.stderr.write(payload.error);
+    return payload.exitCode;
+  }
+
+  if (parsed.options.writeLocal && payload.ok) {
+    await mkdir(path.dirname(payload.artifactPath), { recursive: true });
+    await writeFile(payload.artifactPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  }
+
+  if (parsed.options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write(formatHighRiskDecisionPayload(payload));
+  }
+
+  return payload.exitCode;
+}
+
+export { parseDecideHighRiskExecutionOptions };

package/cli/commands/doctor.mjs

@@ -0,0 +1,53 @@
+import { formatDoctorResult, inspectDoctorState } from "../lib/shared.mjs";
+import { localize } from "../lib/ui.mjs";
+
+function parseDoctorOptions(args) {
+  const options = {
+    json: false,
+    verbose: false,
+  };
+
+  for (const arg of args) {
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--verbose") {
+      options.verbose = true;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding doctor refused: unknown option ${arg}.`,
+        `nimicoding doctor 已拒绝：未知选项 ${arg}。`,
+      )}\n`,
+    };
+  }
+
+  return {
+    ok: true,
+    options,
+  };
+}
+
+export async function runDoctor(args) {
+  const parsed = parseDoctorOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  const result = await inspectDoctorState(process.cwd());
+  if (parsed.options.json) {
+    process.stdout.write(`${JSON.stringify(result, null, 2)}\n`);
+  } else {
+    process.stdout.write(formatDoctorResult(result, { verbose: parsed.options.verbose }));
+  }
+
+  return result.ok ? 0 : 1;
+}
+
+export { parseDoctorOptions };

package/cli/commands/generate-spec-derived-docs.mjs

@@ -0,0 +1,131 @@
+import { localize } from "../lib/ui.mjs";
+import { loadGovernanceConfig, requireProfile } from "../lib/internal/governance/config.mjs";
+import { runCommand } from "../lib/internal/governance/runner.mjs";
+
+function parseOptions(args) {
+  const options = {
+    profile: null,
+    scope: "all",
+    check: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--profile") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        return { ok: false, error: "nimicoding generate-spec-derived-docs refused: --profile requires a value.\n" };
+      }
+      options.profile = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--scope") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        return { ok: false, error: "nimicoding generate-spec-derived-docs refused: --scope requires a value.\n" };
+      }
+      options.scope = value;
+      index += 1;
+      continue;
+    }
+
+    if (arg === "--check") {
+      options.check = true;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `nimicoding generate-spec-derived-docs refused: unknown option ${arg}.\n`,
+    };
+  }
+
+  return { ok: true, options };
+}
+
+function resolveScopes(scope, governanceConfig) {
+  const configuredScopes = Object.keys(governanceConfig.specGovernance.generateCommands || {});
+  if (scope === "all") {
+    return {
+      ok: true,
+      scopes: configuredScopes,
+      error: null,
+    };
+  }
+  if (!configuredScopes.includes(scope)) {
+    return {
+      ok: false,
+      scopes: [],
+      error: `nimicoding generate-spec-derived-docs refused: unsupported --scope value ${scope}.\n`,
+    };
+  }
+  return {
+    ok: true,
+    scopes: [scope],
+    error: null,
+  };
+}
+
+export async function runGenerateSpecDerivedDocs(args) {
+  const parsed = parseOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(localize(parsed.error, parsed.error));
+    return 2;
+  }
+
+  const governance = await loadGovernanceConfig(process.cwd());
+  if (!governance.ok) {
+    process.stderr.write(localize(
+      `nimicoding generate-spec-derived-docs refused: ${governance.reason} at ${governance.path}.\n`,
+      `nimicoding generate-spec-derived-docs 已拒绝：${governance.path} 的治理配置不可用。\n`,
+    ));
+    return 2;
+  }
+
+  const profileCheck = requireProfile(governance.config, parsed.options.profile);
+  if (!profileCheck.ok) {
+    process.stderr.write(localize(
+      `nimicoding generate-spec-derived-docs refused: ${profileCheck.error}.\n`,
+      `nimicoding generate-spec-derived-docs 已拒绝：${profileCheck.error}。\n`,
+    ));
+    return 2;
+  }
+
+  const scopeResolution = resolveScopes(parsed.options.scope, governance.config);
+  if (!scopeResolution.ok) {
+    process.stderr.write(localize(scopeResolution.error, scopeResolution.error));
+    return 2;
+  }
+
+  let failed = false;
+  for (const scope of scopeResolution.scopes) {
+    const commands = governance.config.specGovernance.generateCommands[scope] || [];
+    if (commands.length === 0) {
+      process.stderr.write(localize(
+        `nimicoding generate-spec-derived-docs refused: scope ${scope} is not configured in .nimi/config/governance.yaml.\n`,
+        `nimicoding generate-spec-derived-docs 已拒绝：.nimi/config/governance.yaml 未配置 ${scope}。\n`,
+      ));
+      return 2;
+    }
+
+    for (const command of commands) {
+      const commandToRun = parsed.options.check ? `${command} --check` : command;
+      const result = runCommand(commandToRun, { cwd: process.cwd() });
+      if (result.stdout) process.stdout.write(result.stdout);
+      if (result.stderr) process.stderr.write(result.stderr);
+      if (!result.ok) {
+        failed = true;
+        break;
+      }
+    }
+
+    if (failed) {
+      break;
+    }
+  }
+
+  return failed ? 1 : 0;
+}

package/cli/commands/handoff.mjs

@@ -0,0 +1,123 @@
+import {
+  buildHandoffPayload,
+  formatHandoffPayload,
+  writeHandoffPromptArtifacts,
+} from "../lib/shared.mjs";
+import {
+  localize,
+  styleCommand,
+  styleHeading,
+  styleLabel,
+} from "../lib/ui.mjs";
+
+function parseHandoffOptions(args) {
+  const options = {
+    json: false,
+    prompt: false,
+    skill: null,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--prompt") {
+      options.prompt = true;
+      continue;
+    }
+
+    if (arg === "--skill") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        return {
+          ok: false,
+          error: localize(
+            "nimicoding handoff refused: --skill requires a skill id.\n",
+            "nimicoding handoff 拒绝执行：--skill 需要一个 skill id。\n",
+          ),
+        };
+      }
+      options.skill = next;
+      index += 1;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: localize(
+        `nimicoding handoff refused: unknown option ${arg}.\n`,
+        `nimicoding handoff 拒绝执行：未知选项 ${arg}。\n`,
+      ),
+    };
+  }
+
+  if (!options.skill) {
+    return {
+      ok: false,
+      error: localize(
+        "nimicoding handoff refused: explicit --skill is required.\n",
+        "nimicoding handoff 拒绝执行：必须显式提供 --skill。\n",
+      ),
+    };
+  }
+
+  if (options.json && options.prompt) {
+    return {
+      ok: false,
+      error: localize(
+        "nimicoding handoff refused: --json and --prompt are mutually exclusive.\n",
+        "nimicoding handoff 拒绝执行：--json 与 --prompt 不能同时使用。\n",
+      ),
+    };
+  }
+
+  return {
+    ok: true,
+    options,
+  };
+}
+
+export async function runHandoff(args) {
+  const parsed = parseHandoffOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  const payload = await buildHandoffPayload(process.cwd(), parsed.options.skill);
+  if (parsed.options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else if (parsed.options.prompt) {
+    if (!payload.ok) {
+      process.stderr.write(`${localize(payload.nextAction, payload.nextAction
+        .replace("Bootstrap or handoff validation is failing; repair doctor errors before exporting handoff payloads", "bootstrap 或 handoff 校验失败；请先修复 doctor 报错，再导出 handoff payload")
+        .replace("Projects may delegate spec reconstruction to an external AI host when lifecycle repair or reconstruction work is needed", "当需要 lifecycle repair 或 reconstruction 工作时，项目可以将 spec reconstruction 委托给外部 AI host")
+        .replace("This skill requires the canonical tree under `.nimi/spec` before handoff", "该 skill 在 handoff 前需要 `.nimi/spec` 下的 canonical tree")
+        .replace("Skill prerequisites are satisfied by the current project-local truth", "当前项目本地 truth 已满足该 skill 的前置条件"))}\n`);
+      return payload.exitCode;
+    }
+
+    const refs = await writeHandoffPromptArtifacts(process.cwd(), payload);
+    process.stdout.write(`${styleHeading(localize(`Prepared local handoff refs for ${payload.skill.id}`, `已为 ${payload.skill.id} 准备本地 handoff ref`))}
+
+${styleLabel(localize("Created:", "已创建："))}
+  - ${refs.jsonRef}
+  - ${refs.promptRef}
+
+${styleLabel(localize("Use:", "使用方式："))}
+  - ${localize(`Treat ${refs.jsonRef} as the authoritative machine contract`, `将 ${refs.jsonRef} 作为权威机器契约`)}
+  - ${localize(`Paste the contents of ${refs.promptRef} into the external AI host when needed`, `需要时将 ${refs.promptRef} 的内容粘贴给外部 AI host`)}
+  - ${localize("Optional command preview:", "可选命令预览：")} ${styleCommand(`nimicoding handoff --skill ${payload.skill.id} --json`)}
+`);
+  } else {
+    process.stdout.write(formatHandoffPayload(payload));
+  }
+
+  return payload.exitCode;
+}
+
+export { parseHandoffOptions };

package/cli/commands/ingest-high-risk-execution.mjs

@@ -0,0 +1,95 @@
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import {
+  buildHighRiskIngestPayload,
+  formatHighRiskIngestPayload,
+} from "../lib/high-risk-ingest.mjs";
+import { localize } from "../lib/ui.mjs";
+
+function parseIngestHighRiskExecutionOptions(args) {
+  const options = {
+    fromPath: null,
+    json: false,
+    writeLocal: false,
+  };
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    if (arg === "--write-local") {
+      options.writeLocal = true;
+      continue;
+    }
+
+    if (arg === "--from") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        return {
+          ok: false,
+          error: `${localize(
+            "nimicoding ingest-high-risk-execution refused: --from requires a value.",
+            "nimicoding ingest-high-risk-execution 已拒绝：`--from` 需要一个值。",
+          )}\n`,
+        };
+      }
+      options.fromPath = next;
+      index += 1;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding ingest-high-risk-execution refused: unknown option ${arg}.`,
+        `nimicoding ingest-high-risk-execution 已拒绝：未知选项 ${arg}。`,
+      )}\n`,
+    };
+  }
+
+  if (!options.fromPath) {
+    return {
+      ok: false,
+      error: `${localize(
+        "nimicoding ingest-high-risk-execution refused: explicit --from is required.",
+        "nimicoding ingest-high-risk-execution 已拒绝：必须显式提供 `--from`。",
+      )}\n`,
+    };
+  }
+
+  return { ok: true, options };
+}
+
+export async function runIngestHighRiskExecution(args) {
+  const parsed = parseIngestHighRiskExecutionOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  const payload = await buildHighRiskIngestPayload(process.cwd(), parsed.options.fromPath, parsed.options);
+  if (payload.inputError) {
+    process.stderr.write(payload.error);
+    return payload.exitCode;
+  }
+
+  if (parsed.options.writeLocal && payload.ok) {
+    await mkdir(path.dirname(payload.artifactPath), { recursive: true });
+    await writeFile(payload.artifactPath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+  }
+
+  if (parsed.options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write(formatHighRiskIngestPayload(payload));
+  }
+
+  return payload.exitCode;
+}
+
+export { parseIngestHighRiskExecutionOptions };