@nimiplatform/nimi-coding 0.2.8 → 0.3.1

package/cli/commands/audit-sweep.mjs

@@ -1,364 +0,0 @@
-import {
-  buildAuditSweepCloseoutImport,
-  buildAuditSweepLedger,
-  buildAuditSweepRemediationMap,
-  createAuditSweepPlan,
-  admitAuditSweepRemediationMap,
-  dispatchAuditSweepChunk,
-  formatAuditSweepPayload,
-  getAuditSweepStatus,
-  ingestAuditSweepChunk,
-  resolveAuditSweepFinding,
-  reviewAuditSweepChunk,
-  runClaudeAuditSweepChunk,
-  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 sweep audit ${commandName} refused: ${optionName} requires a value.`,
-        `nimicoding sweep audit ${commandName} 已拒绝：${optionName} 需要一个值。`,
-      )}\n`,
-    };
-  }
-  return { ok: true, value: next };
-}
-
-function unknownOption(commandName, arg) {
-  return {
-    ok: false,
-    error: `${localize(
-      `nimicoding sweep audit ${commandName} refused: unknown option ${arg}.`,
-      `nimicoding sweep audit ${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 sweep audit ${commandName} refused: ${arg} must be a positive integer.`,
-            `nimicoding sweep audit ${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 sweep audit ${commandName} refused: missing required options: ${missing.join(", ")}.`,
-        `nimicoding sweep audit ${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 parseChunkAuditClaudeOptions(args) {
-  return parseOptions(args, "chunk audit-claude", {
-    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" },
-    claudeBin: { flag: "--claude-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 === "audit-claude") {
-    return { ok: true, action: "chunk-audit-claude", parsed: parseChunkAuditClaudeOptions(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 sweep audit refused: expected one of `plan`, `chunk dispatch`, `chunk audit-codex`, `chunk audit-claude`, `chunk ingest`, `chunk review`, `chunk skip`, `ledger build`, `remediation-map build`, `remediation-map admit`, `finding resolve`, `closeout summary`, `status`, or `validate`.",
-      "nimicoding sweep audit 已拒绝：需要使用 `plan`、`chunk dispatch`、`chunk audit-codex`、`chunk audit-claude`、`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-audit-claude": runClaudeAuditSweepChunk,
-    "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,
-  parseChunkAuditClaudeOptions,
-  parseChunkAuditCodexOptions,
-  parseChunkDispatchOptions,
-  parseChunkIngestOptions,
-  parseChunkReviewOptions,
-  parseChunkSkipOptions,
-  parseFindingResolveOptions,
-  parsePlanOptions,
-  parseRemediationMapAdmitOptions,
-  parseRemediationMapBuildOptions,
-  parseValidateOptions,
-};

package/cli/commands/closeout.mjs

@@ -1,186 +0,0 @@
-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);
-    if (parsed.options.json) {
-      process.stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-    }
-    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

@@ -1,124 +0,0 @@
-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 };