@nimiplatform/nimi-coding 0.1.0

package/cli/commands/audit-sweep.mjs

@@ -0,0 +1,341 @@
+import {
+  buildAuditSweepCloseoutImport,
+  buildAuditSweepLedger,
+  buildAuditSweepRemediationMap,
+  createAuditSweepPlan,
+  admitAuditSweepRemediationMap,
+  dispatchAuditSweepChunk,
+  formatAuditSweepPayload,
+  getAuditSweepStatus,
+  ingestAuditSweepChunk,
+  resolveAuditSweepFinding,
+  reviewAuditSweepChunk,
+  runCodexAuditSweepChunk,
+  skipAuditSweepChunk,
+  validateAuditSweepArtifacts,
+} from "../lib/audit-sweep.mjs";
+import { localize } from "../lib/ui.mjs";
+
+function readRequiredValue(args, index, optionName, commandName) {
+  const next = args[index + 1];
+  if (!next || next.startsWith("--")) {
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding audit-sweep ${commandName} refused: ${optionName} requires a value.`,
+        `nimicoding audit-sweep ${commandName} 已拒绝：${optionName} 需要一个值。`,
+      )}\n`,
+    };
+  }
+  return { ok: true, value: next };
+}
+
+function unknownOption(commandName, arg) {
+  return {
+    ok: false,
+    error: `${localize(
+      `nimicoding audit-sweep ${commandName} refused: unknown option ${arg}.`,
+      `nimicoding audit-sweep ${commandName} 已拒绝：未知选项 ${arg}。`,
+    )}\n`,
+  };
+}
+
+function parseOptions(args, commandName, spec) {
+  const options = Object.fromEntries(Object.entries(spec).map(([name, config]) => [name, config.default ?? null]));
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      options.json = true;
+      continue;
+    }
+
+    const entry = Object.entries(spec).find(([, config]) => config.flag === arg);
+    if (!entry) {
+      return unknownOption(commandName, arg);
+    }
+    const [name, config] = entry;
+    const value = readRequiredValue(args, index, arg, commandName);
+    if (!value.ok) {
+      return value;
+    }
+    if (config.type === "positive-int") {
+      const parsed = Number(value.value);
+      if (!Number.isInteger(parsed) || parsed <= 0) {
+        return {
+          ok: false,
+          error: `${localize(
+            `nimicoding audit-sweep ${commandName} refused: ${arg} must be a positive integer.`,
+            `nimicoding audit-sweep ${commandName} 已拒绝：${arg} 必须是正整数。`,
+          )}\n`,
+        };
+      }
+      options[name] = parsed;
+    } else {
+      options[name] = value.value;
+    }
+    index += 1;
+  }
+
+  const missing = Object.entries(spec)
+    .filter(([, config]) => config.required)
+    .filter(([name]) => !options[name])
+    .map(([, config]) => config.flag);
+  if (missing.length > 0) {
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding audit-sweep ${commandName} refused: missing required options: ${missing.join(", ")}.`,
+        `nimicoding audit-sweep ${commandName} 已拒绝：缺少必填选项：${missing.join(", ")}。`,
+      )}\n`,
+    };
+  }
+
+  return { ok: true, options };
+}
+
+function parsePlanOptions(args) {
+  return parseOptions(args, "plan", {
+    root: { flag: "--root", required: true },
+    chunkBasis: { flag: "--chunk-basis" },
+    criteria: { flag: "--criteria" },
+    exclude: { flag: "--exclude" },
+    ignore: { flag: "--ignore" },
+    ignoreOwner: { flag: "--ignore-owner" },
+    ignoreReason: { flag: "--ignore-reason" },
+    maxFilesPerChunk: { flag: "--max-files", type: "positive-int" },
+    maxSweepFindings: { flag: "--max-sweep-findings", type: "positive-int" },
+    maxDomainFindings: { flag: "--max-domain-findings", type: "positive-int" },
+    maxSweepHighRiskFindings: { flag: "--max-sweep-high-risk-findings", type: "positive-int" },
+    maxDomainHighRiskFindings: { flag: "--max-domain-high-risk-findings", type: "positive-int" },
+    sweepId: { flag: "--sweep-id" },
+    json: { default: false },
+  });
+}
+
+function parseChunkDispatchOptions(args) {
+  return parseOptions(args, "chunk dispatch", {
+    sweepId: { flag: "--sweep-id", required: true },
+    chunkId: { flag: "--chunk-id", required: true },
+    dispatchedAt: { flag: "--dispatched-at", required: true },
+    auditor: { flag: "--auditor" },
+    json: { default: false },
+  });
+}
+
+function parseChunkIngestOptions(args) {
+  return parseOptions(args, "chunk ingest", {
+    sweepId: { flag: "--sweep-id", required: true },
+    chunkId: { flag: "--chunk-id", required: true },
+    fromPath: { flag: "--from", required: true },
+    verifiedAt: { flag: "--verified-at", required: true },
+    json: { default: false },
+  });
+}
+
+function parseChunkAuditCodexOptions(args) {
+  return parseOptions(args, "chunk audit-codex", {
+    sweepId: { flag: "--sweep-id", required: true },
+    chunkId: { flag: "--chunk-id", required: true },
+    dispatchedAt: { flag: "--dispatched-at", required: true },
+    verifiedAt: { flag: "--verified-at", required: true },
+    reviewedAt: { flag: "--reviewed-at", required: true },
+    auditor: { flag: "--auditor" },
+    reviewer: { flag: "--reviewer" },
+    summary: { flag: "--summary" },
+    codexBin: { flag: "--codex-bin" },
+    fromRawOutput: { flag: "--from-raw-output" },
+    timeoutMs: { flag: "--timeout-ms", type: "positive-int" },
+    json: { default: false },
+  });
+}
+
+function parseChunkReviewOptions(args) {
+  return parseOptions(args, "chunk review", {
+    sweepId: { flag: "--sweep-id", required: true },
+    chunkId: { flag: "--chunk-id", required: true },
+    verdict: { flag: "--verdict", required: true },
+    reviewedAt: { flag: "--reviewed-at", required: true },
+    reviewer: { flag: "--reviewer" },
+    summary: { flag: "--summary" },
+    json: { default: false },
+  });
+}
+
+function parseChunkSkipOptions(args) {
+  return parseOptions(args, "chunk skip", {
+    sweepId: { flag: "--sweep-id", required: true },
+    chunkId: { flag: "--chunk-id", required: true },
+    reason: { flag: "--reason", required: true },
+    skippedAt: { flag: "--skipped-at", required: true },
+    json: { default: false },
+  });
+}
+
+function parseLedgerBuildOptions(args) {
+  return parseOptions(args, "ledger build", {
+    sweepId: { flag: "--sweep-id", required: true },
+    verifiedAt: { flag: "--verified-at" },
+    json: { default: false },
+  });
+}
+
+function parseRemediationMapBuildOptions(args) {
+  return parseOptions(args, "remediation-map build", {
+    sweepId: { flag: "--sweep-id", required: true },
+    verifiedAt: { flag: "--verified-at" },
+    maxFindingsPerWave: { flag: "--max-findings", type: "positive-int" },
+    json: { default: false },
+  });
+}
+
+function parseRemediationMapAdmitOptions(args) {
+  return parseOptions(args, "remediation-map admit", {
+    sweepId: { flag: "--sweep-id", required: true },
+    topicId: { flag: "--topic-id", required: true },
+    json: { default: false },
+  });
+}
+
+function parseFindingResolveOptions(args) {
+  return parseOptions(args, "finding resolve", {
+    sweepId: { flag: "--sweep-id", required: true },
+    findingId: { flag: "--finding-id", required: true },
+    disposition: { flag: "--disposition", required: true },
+    fromPath: { flag: "--from", required: true },
+    verifiedAt: { flag: "--verified-at", required: true },
+    json: { default: false },
+  });
+}
+
+function parseSweepIdOptions(args, commandName, timestampRequired = false) {
+  return parseOptions(args, commandName, {
+    sweepId: { flag: "--sweep-id", required: true },
+    verifiedAt: { flag: "--verified-at", required: timestampRequired },
+    json: { default: false },
+  });
+}
+
+function parseValidateOptions(args) {
+  return parseOptions(args, "validate", {
+    sweepId: { flag: "--sweep-id", required: true },
+    scope: { flag: "--scope", default: "all" },
+    json: { default: false },
+  });
+}
+
+function parseAuditSweepOptions(args) {
+  const [command, subcommand] = args;
+  if (command === "plan") {
+    return { ok: true, action: "plan", parsed: parsePlanOptions(args.slice(1)) };
+  }
+  if (command === "chunk" && subcommand === "dispatch") {
+    return { ok: true, action: "chunk-dispatch", parsed: parseChunkDispatchOptions(args.slice(2)) };
+  }
+  if (command === "chunk" && subcommand === "ingest") {
+    return { ok: true, action: "chunk-ingest", parsed: parseChunkIngestOptions(args.slice(2)) };
+  }
+  if (command === "chunk" && subcommand === "audit-codex") {
+    return { ok: true, action: "chunk-audit-codex", parsed: parseChunkAuditCodexOptions(args.slice(2)) };
+  }
+  if (command === "chunk" && subcommand === "review") {
+    return { ok: true, action: "chunk-review", parsed: parseChunkReviewOptions(args.slice(2)) };
+  }
+  if (command === "chunk" && subcommand === "skip") {
+    return { ok: true, action: "chunk-skip", parsed: parseChunkSkipOptions(args.slice(2)) };
+  }
+  if (command === "ledger" && subcommand === "build") {
+    return { ok: true, action: "ledger-build", parsed: parseLedgerBuildOptions(args.slice(2)) };
+  }
+  if (command === "remediation-map" && subcommand === "build") {
+    return { ok: true, action: "remediation-map-build", parsed: parseRemediationMapBuildOptions(args.slice(2)) };
+  }
+  if (command === "remediation-map" && subcommand === "admit") {
+    return { ok: true, action: "remediation-map-admit", parsed: parseRemediationMapAdmitOptions(args.slice(2)) };
+  }
+  if (command === "finding" && subcommand === "resolve") {
+    return { ok: true, action: "finding-resolve", parsed: parseFindingResolveOptions(args.slice(2)) };
+  }
+  if (command === "closeout" && subcommand === "summary") {
+    return { ok: true, action: "closeout-summary", parsed: parseSweepIdOptions(args.slice(2), "closeout summary", true) };
+  }
+  if (command === "status") {
+    return { ok: true, action: "status", parsed: parseSweepIdOptions(args.slice(1), "status") };
+  }
+  if (command === "validate") {
+    return { ok: true, action: "validate", parsed: parseValidateOptions(args.slice(1)) };
+  }
+
+  return {
+    ok: false,
+    error: `${localize(
+      "nimicoding audit-sweep refused: expected one of `plan`, `chunk dispatch`, `chunk audit-codex`, `chunk ingest`, `chunk review`, `chunk skip`, `ledger build`, `remediation-map build`, `remediation-map admit`, `finding resolve`, `closeout summary`, `status`, or `validate`.",
+      "nimicoding audit-sweep 已拒绝：需要使用 `plan`、`chunk dispatch`、`chunk ingest`、`chunk review`、`chunk skip`、`ledger build`、`remediation-map build`、`remediation-map admit`、`finding resolve`、`closeout summary`、`status` 或 `validate`。",
+    )}\n`,
+  };
+}
+
+function writeStream(stream, text) {
+  return new Promise((resolve, reject) => {
+    stream.write(text, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve();
+    });
+  });
+}
+
+export async function runAuditSweep(args) {
+  const selected = parseAuditSweepOptions(args);
+  if (!selected.ok) {
+    process.stderr.write(selected.error);
+    return 2;
+  }
+  if (!selected.parsed.ok) {
+    process.stderr.write(selected.parsed.error);
+    return 2;
+  }
+
+  const runners = {
+    plan: createAuditSweepPlan,
+    "chunk-dispatch": dispatchAuditSweepChunk,
+    "chunk-ingest": ingestAuditSweepChunk,
+    "chunk-audit-codex": runCodexAuditSweepChunk,
+    "chunk-review": reviewAuditSweepChunk,
+    "chunk-skip": skipAuditSweepChunk,
+    "ledger-build": buildAuditSweepLedger,
+    "remediation-map-build": buildAuditSweepRemediationMap,
+    "remediation-map-admit": admitAuditSweepRemediationMap,
+    "finding-resolve": resolveAuditSweepFinding,
+    "closeout-summary": buildAuditSweepCloseoutImport,
+    status: getAuditSweepStatus,
+    validate: validateAuditSweepArtifacts,
+  };
+  const payload = await runners[selected.action](process.cwd(), selected.parsed.options);
+  if (payload.inputError) {
+    process.stderr.write(payload.error);
+    return payload.exitCode;
+  }
+  if (selected.parsed.options.json) {
+    await writeStream(process.stdout, `${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    await writeStream(process.stdout, formatAuditSweepPayload(payload));
+  }
+  return payload.exitCode;
+}
+
+export {
+  parseAuditSweepOptions,
+  parseChunkAuditCodexOptions,
+  parseChunkDispatchOptions,
+  parseChunkIngestOptions,
+  parseChunkReviewOptions,
+  parseChunkSkipOptions,
+  parseFindingResolveOptions,
+  parsePlanOptions,
+  parseRemediationMapAdmitOptions,
+  parseRemediationMapBuildOptions,
+  parseValidateOptions,
+};

package/cli/commands/blueprint-audit.mjs

@@ -0,0 +1,91 @@
+import {
+  buildBlueprintAuditPayload,
+  formatBlueprintAuditPayload,
+  writeBlueprintAuditArtifact,
+} from "../lib/shared.mjs";
+import { localize } from "../lib/ui.mjs";
+
+function parseBlueprintAuditOptions(args) {
+  const options = {
+    json: false,
+    writeLocal: false,
+    blueprintRoot: null,
+    canonicalRoot: 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 === "--blueprint-root" || arg === "--canonical-root") {
+      const next = args[index + 1];
+      if (!next || next.startsWith("--")) {
+        return {
+          ok: false,
+          error: `${localize(
+            `nimicoding blueprint-audit refused: ${arg} requires a value.`,
+            `nimicoding blueprint-audit 已拒绝：${arg} 需要一个值。`,
+          )}\n`,
+        };
+      }
+
+      if (arg === "--blueprint-root") {
+        options.blueprintRoot = next;
+      } else {
+        options.canonicalRoot = next;
+      }
+      index += 1;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding blueprint-audit refused: unknown option ${arg}.`,
+        `nimicoding blueprint-audit 已拒绝：未知选项 ${arg}。`,
+      )}\n`,
+    };
+  }
+
+  return {
+    ok: true,
+    options,
+  };
+}
+
+export async function runBlueprintAudit(args) {
+  const parsed = parseBlueprintAuditOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  const payload = await buildBlueprintAuditPayload(process.cwd(), parsed.options);
+  if (payload.inputError) {
+    process.stderr.write(payload.error);
+    return payload.exitCode;
+  }
+
+  if (parsed.options.writeLocal) {
+    await writeBlueprintAuditArtifact(process.cwd(), payload);
+  }
+
+  if (parsed.options.json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
+  } else {
+    process.stdout.write(formatBlueprintAuditPayload(payload));
+  }
+
+  return payload.exitCode;
+}
+
+export { parseBlueprintAuditOptions };

package/cli/commands/clear.mjs

@@ -0,0 +1,168 @@
+import { createInterface } from "node:readline/promises";
+import process from "node:process";
+
+import {
+  previewBootstrapRemoval,
+  previewEntrypointRemoval,
+  removeManagedBootstrapFiles,
+  removeManagedEntrypoints,
+} from "../lib/shared.mjs";
+import {
+  localize,
+  styleHeading,
+  styleLabel,
+  styleMuted,
+} from "../lib/ui.mjs";
+
+function parseClearOptions(args) {
+  const options = {
+    yes: false,
+  };
+
+  for (const arg of args) {
+    if (arg === "--yes") {
+      options.yes = true;
+      continue;
+    }
+
+    return {
+      ok: false,
+      error: `${localize(
+        `nimicoding clear refused: unknown option ${arg}.`,
+        `nimicoding clear 已拒绝：未知选项 ${arg}。`,
+      )}\n`,
+    };
+  }
+
+  return { ok: true, options };
+}
+
+function canPromptInteractively() {
+  return Boolean(process.stdin.isTTY && process.stdout.isTTY);
+}
+
+async function confirmClear(prompt) {
+  const rl = createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  try {
+    const answer = (await rl.question(`${prompt}${localize(" [Y/n] ", " [Y/n] ")}`)).trim().toLowerCase();
+    if (answer.length === 0) {
+      return true;
+    }
+    return answer === "y" || answer === "yes";
+  } finally {
+    rl.close();
+  }
+}
+
+function formatList(items, emptyLine) {
+  return items.length > 0 ? items.map((item) => `  - ${item}`).join("\n") : emptyLine;
+}
+
+export async function runClear(args) {
+  const parsed = parseClearOptions(args);
+  if (!parsed.ok) {
+    process.stderr.write(parsed.error);
+    return 2;
+  }
+
+  const projectRoot = process.cwd();
+  const entrypointPreview = await previewEntrypointRemoval(projectRoot);
+  const bootstrapPreview = await previewBootstrapRemoval(projectRoot);
+
+  if (canPromptInteractively() && !parsed.options.yes) {
+    process.stdout.write(`${styleHeading(localize(`nimicoding clear: ${projectRoot}`, `nimicoding clear：${projectRoot}`))}
+
+${styleLabel(localize("What I can clear:", "我可以清理的内容："))}
+${formatList(
+  [
+    ...entrypointPreview.map((filePath) => `${localize("managed AI block in", "托管 AI 区块：")} ${filePath}`),
+    ...bootstrapPreview.removableFiles,
+  ],
+  localize("  - no nimicoding-managed files are ready to clear", "  - 当前没有可清理的 nimicoding 托管文件"),
+)}
+
+${styleLabel(localize("What I will keep:", "我会保留的内容："))}
+  - .nimi/spec/**
+  - .nimi/local/**
+  - .nimi/cache/**
+${bootstrapPreview.preservedModifiedFiles.length > 0
+    ? `\n${styleMuted(localize("I also found package-owned bootstrap files that were changed locally, so I will leave them in place:", "我还发现了一些包拥有的 bootstrap 文件已被本地修改，因此我会保留它们："))}\n${bootstrapPreview.preservedModifiedFiles.map((filePath) => `  - ${filePath}`).join("\n")}`
+    : ""}
+
+`);
+  }
+
+  const hasWork = entrypointPreview.length > 0 || bootstrapPreview.removableFiles.length > 0;
+  if (!hasWork && bootstrapPreview.preservedModifiedFiles.length === 0) {
+    process.stdout.write(`${styleHeading(localize(`nimicoding clear: ${projectRoot}`, `nimicoding clear：${projectRoot}`))}
+
+${styleLabel(localize("What I cleared:", "我已清理的内容："))}
+${localize("  - nothing needed clearing", "  - 没有需要清理的内容")}
+
+${styleLabel(localize("What I kept:", "我保留的内容："))}
+  - .nimi/spec/**
+  - .nimi/local/**
+  - .nimi/cache/**
+
+${styleMuted(localize("No nimicoding-managed bootstrap files or managed AI blocks were found.", "没有检测到 nimicoding 托管的 bootstrap 文件或托管 AI 区块。"))}
+`);
+    return 0;
+  }
+
+  if (!parsed.options.yes && canPromptInteractively()) {
+    const approved = await confirmClear(localize(
+      "Clear the nimicoding-managed setup now?",
+      "现在清理 nimicoding 托管的项目初始化内容吗？",
+    ));
+    if (!approved) {
+      process.stdout.write(`${styleHeading(localize("nimicoding clear canceled", "nimicoding clear 已取消"))}
+
+${styleMuted(localize("No files were changed.", "没有修改任何文件。"))}
+`);
+      return 0;
+    }
+  }
+
+  const removedEntrypoints = await removeManagedEntrypoints(projectRoot);
+  const removedBootstrap = await removeManagedBootstrapFiles(projectRoot);
+
+  process.stdout.write(`${styleHeading(localize(`nimicoding clear: ${projectRoot}`, `nimicoding clear：${projectRoot}`))}
+
+${styleLabel(localize("What I cleared:", "我已清理的内容："))}
+${formatList(
+  [
+    ...removedEntrypoints.updatedFiles.map((filePath) => `${localize("updated", "已更新")}: ${filePath}`),
+    ...removedEntrypoints.removedFiles.map((filePath) => `${localize("removed", "已移除")}: ${filePath}`),
+    ...removedBootstrap.removedFiles.map((filePath) => `${localize("removed", "已移除")}: ${filePath}`),
+    ...removedBootstrap.removedDirs.map((dirPath) => `${localize("removed empty dir", "已移除空目录")}: ${dirPath}/`),
+  ],
+  localize("  - nothing was cleared", "  - 没有清理任何内容"),
+)}
+
+${styleLabel(localize("What I kept:", "我保留的内容："))}
+  - .nimi/spec/**
+  - .nimi/local/**
+  - .nimi/cache/**
+${removedBootstrap.preservedModifiedFiles.length > 0
+    ? `\n${removedBootstrap.preservedModifiedFiles.map((filePath) => `  - ${localize("kept because it was modified", "已保留，因为它已被修改")}: ${filePath}`).join("\n")}`
+    : ""}
+
+${styleLabel(localize("What You Should Review Next:", "你下一步应该检查什么："))}
+  - ${localize(
+    "If you want to fully remove project-local AI truth, review .nimi/spec/** and local artifacts manually.",
+    "如果你想完整移除项目本地 AI truth，请手动检查 .nimi/spec/** 和本地产物。",
+  )}
+  - ${localize(
+    "If you want nimicoding again later, run `nimicoding start`.",
+    "如果以后还要重新接入 nimicoding，请运行 `nimicoding start`。",
+  )}
+`);
+
+  return 0;
+}
+
+export { parseClearOptions };