@moda-ai/cli 1.55.10 → 1.55.11

package/dist/agent-n0ch2j90.js

@@ -0,0 +1,459 @@
+import {
+  buildDoctorReport
+} from "./cli-11fevr8y.js";
+import"./cli-t4jjhn3g.js";
+import"./cli-fq7kk77e.js";
+import"./cli-mm48br00.js";
+import {
+  HARNESS_REPORT_APPROVAL_PATH,
+  HARNESS_REPORT_PATH,
+  graphForSync,
+  hashHarnessReport,
+  hashStableJson,
+  readHarnessReport,
+  readHarnessSyncState,
+  summarizeHarness,
+  validateHarnessReport
+} from "./cli-m857n028.js";
+import"./cli-97fnztpy.js";
+import"./cli-k5qqj2bp.js";
+import"./cli-g7ferymy.js";
+import"./cli-tmqd1f0m.js";
+import"./cli-m16taf4z.js";
+import {
+  CliInputError,
+  resolveApiKey,
+  resolveIngestUrl,
+  resolveModaBaseUrl,
+  resolveTenantId
+} from "./cli-429zt7g4.js";
+import"./cli-0v6na3yp.js";
+
+// src/agent.ts
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { join, relative, resolve } from "node:path";
+var MODA_DIR = ".moda";
+var HARNESS_PATH = join(MODA_DIR, "harness.json");
+var HARNESS_REPORT_MARKDOWN_PATH = join(MODA_DIR, "HARNESS_REPORT.md");
+var HARNESS_SUMMARY_PATH = join(MODA_DIR, "HARNESS.md");
+async function runAgentCommand(context) {
+  const subcommand = context.positionals[0] ?? "context";
+  switch (subcommand) {
+    case "context": {
+      const loaded = await buildAgentContext(context);
+      context.output.writeData(loaded.payload, agentWriteOptions(loaded));
+      return { exitCode: 0 };
+    }
+    case "investigate": {
+      const passthrough = Object.entries(context.flags).filter(([key]) => ["days-back", "tool", "trace", "conversation"].includes(key)).map(([key, value]) => `--${key}=${value}`);
+      throw new CliInputError("'moda agent investigate' has been removed. Use 'moda investigate' for the ranked production investigation.", `Run: ${["moda investigate", ...passthrough].join(" ")} (flags: --days-back, --tool, --trace). For local readiness use 'moda agent context'.`);
+    }
+    case "next-action":
+    case "next-actions": {
+      const loaded = await buildAgentContext(context);
+      context.output.writeData({
+        schemaVersion: "agent_next_actions.v0.1",
+        generatedAt: loaded.payload.generatedAt,
+        status: loaded.payload.doctor.status,
+        recommendedActions: loaded.payload.recommendedActions,
+        nextCommands: loaded.payload.nextCommands
+      }, agentWriteOptions(loaded, {
+        summary: `${loaded.payload.recommendedActions.length} recommended action(s) are ready for an agent to evaluate.`
+      }));
+      return { exitCode: 0 };
+    }
+    case "evidence": {
+      const ref = context.positionals[1] ?? context.flags.id ?? context.flags.ref ?? context.flags.finding;
+      if (!ref) {
+        throw new CliInputError("<ref> is required", "Usage: moda agent evidence <ref>");
+      }
+      const loaded = await buildAgentContext(context);
+      const evidence = expandEvidenceRef(ref, loaded, context.cwd);
+      context.output.writeData(evidence, {
+        summary: {
+          text: `Expanded evidence reference ${ref}.`,
+          confidence: "high"
+        },
+        evidenceRefs: [evidence.ref],
+        artifacts: evidence.artifact ? [evidence.artifact] : []
+      });
+      return { exitCode: 0 };
+    }
+    default:
+      throw new CliInputError(`Unknown agent subcommand '${subcommand}'`, "Usage: moda agent context|next-action|evidence (for production issues use moda investigate)");
+  }
+}
+async function buildAgentContext(context) {
+  const doctor = await buildDoctorReport(context, {
+    offline: context.flags.online !== "true"
+  });
+  const graph = readHarnessGraphIfPresent(context.cwd);
+  const reportState = readHarnessReportState(context.cwd);
+  const syncState = readHarnessSyncState(context.cwd);
+  const topFindings = doctor.checks.filter((check) => check.status === "fail" || check.status === "warning").slice(0, 12).map(checkToFinding);
+  const evidenceRefs = [
+    ...doctor.checks.map(checkToEvidenceRef),
+    ...reportEvidenceRefs(reportState.report).slice(0, 60)
+  ];
+  const artifacts = existingArtifacts(context.cwd);
+  const recommendedActions = recommendedActionsForDoctor(doctor);
+  const nextCommands = nextCommandsForActions(recommendedActions, doctor.nextCommands);
+  const payload = {
+    schemaVersion: "agent_context.v0.1",
+    generatedAt: new Date().toISOString(),
+    mode: "local",
+    workspace: {
+      cwd: context.cwd,
+      profile: context.profile,
+      tenantId: resolveTenantId({ profile: context.profile, env: context.env }) ?? null,
+      apiKey: resolveApiKey({ profile: context.profile, env: context.env }) ? "configured" : "missing",
+      baseUrl: resolveModaBaseUrl({ profile: context.profile, env: context.env }),
+      ingestUrl: resolveIngestUrl({ profile: context.profile, env: context.env })
+    },
+    doctor: {
+      status: doctor.summary.status,
+      summary: doctor.summary,
+      topFindings
+    },
+    harness: {
+      manifest: {
+        path: HARNESS_PATH,
+        exists: graph !== undefined,
+        summary: graph ? summarizeHarness(graph) : null
+      },
+      report: reportState.state,
+      sync: syncState ? {
+        path: join(MODA_DIR, "sync-state.json"),
+        exists: true,
+        source: syncState.source,
+        updatedAt: syncState.updatedAt,
+        stale: graph ? syncState.localGraphHash !== hashStableJson(graphForSync(graph)) : undefined,
+        remoteHarnessId: syncState.remote.harnessId,
+        remoteVersionId: syncState.remote.versionId
+      } : {
+        path: join(MODA_DIR, "sync-state.json"),
+        exists: false
+      }
+    },
+    recommendedActions,
+    evidenceRefs,
+    artifacts,
+    nextCommands,
+    limitations: [
+      "This context is local and bounded. It does not upload source content or prove production behavior.",
+      "Use evidence refs to expand claims instead of asking agents to scrape human output."
+    ]
+  };
+  return {
+    payload,
+    doctor,
+    graph,
+    report: reportState.report,
+    reportValidation: reportState.validation,
+    reportApproval: reportState.approval,
+    syncState
+  };
+}
+function agentWriteOptions(loaded, overrides = {}) {
+  return {
+    summary: overrides.summary ?? summarizeAgentContext(loaded.payload, "context"),
+    findings: loaded.payload.doctor.topFindings,
+    evidenceRefs: loaded.payload.evidenceRefs,
+    recommendedActions: loaded.payload.recommendedActions,
+    nextCommands: loaded.payload.nextCommands,
+    artifacts: loaded.payload.artifacts,
+    warnings: [
+      ...loaded.payload.harness.report.warnings ?? [],
+      ...loaded.payload.limitations
+    ].slice(0, 40)
+  };
+}
+function summarizeAgentContext(payload, noun) {
+  const fail = payload.doctor.summary.fail;
+  const warning = payload.doctor.summary.warning;
+  const agents = payload.harness.manifest.summary?.runtimeAgentCount ?? 0;
+  if (fail > 0) {
+    return `Local Moda ${noun} found ${fail} failing check(s), ${warning} warning(s), and ${agents} runtime agent(s).`;
+  }
+  if (warning > 0) {
+    return `Local Moda ${noun} is usable with ${warning} warning(s) and ${agents} runtime agent(s).`;
+  }
+  return `Local Moda ${noun} is healthy with ${agents} runtime agent(s).`;
+}
+function readHarnessGraphIfPresent(cwd) {
+  const path = join(cwd, HARNESS_PATH);
+  if (!existsSync(path))
+    return;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return;
+  }
+}
+function readHarnessReportState(cwd) {
+  const path = join(cwd, HARNESS_REPORT_PATH);
+  if (!existsSync(path)) {
+    return {
+      state: {
+        path: HARNESS_REPORT_PATH,
+        exists: false,
+        status: "missing"
+      }
+    };
+  }
+  try {
+    const report = readHarnessReport(path);
+    const validation = validateHarnessReport(report, cwd);
+    const approval = readApproval(cwd);
+    const reportHash = hashHarnessReport(report);
+    return {
+      state: {
+        path: HARNESS_REPORT_PATH,
+        exists: true,
+        status: validation.status === "pass" ? "valid" : "invalid",
+        reportId: report.reportId,
+        reportHash,
+        validationStatus: validation.status,
+        approved: approval?.approved === true && approval.reportHash === reportHash,
+        claimCount: report.claims.length,
+        citationCount: report.citations.length,
+        warnings: validation.warnings,
+        errors: validation.errors
+      },
+      report,
+      validation,
+      approval
+    };
+  } catch (error) {
+    return {
+      state: {
+        path: HARNESS_REPORT_PATH,
+        exists: true,
+        status: "invalid",
+        errors: [error instanceof Error ? error.message : String(error)]
+      }
+    };
+  }
+}
+function readApproval(cwd) {
+  const path = join(cwd, HARNESS_REPORT_APPROVAL_PATH);
+  if (!existsSync(path))
+    return;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return;
+  }
+}
+function checkToFinding(check) {
+  return {
+    id: check.id,
+    title: check.title,
+    status: check.status,
+    severity: check.severity,
+    description: check.remediation ?? `Doctor check ${check.id} is ${check.status}.`,
+    evidence_ref_ids: [`doctor:${check.id}`]
+  };
+}
+function checkToEvidenceRef(check) {
+  return {
+    id: `doctor:${check.id}`,
+    kind: "doctor_check",
+    label: check.title,
+    status: check.status
+  };
+}
+function reportEvidenceRefs(report) {
+  if (!report)
+    return [];
+  return [
+    ...report.claims.map((claim) => ({
+      id: `harness-report:claim:${claim.id}`,
+      kind: "harness_claim",
+      label: claim.title,
+      status: claim.inference
+    })),
+    ...report.citations.map((citation) => ({
+      id: `harness-report:citation:${citation.id}`,
+      kind: citation.type,
+      label: citation.reason,
+      path: citation.path,
+      line: citation.line
+    }))
+  ];
+}
+function recommendedActionsForDoctor(report) {
+  return report.fixPlan.slice(0, 12).map((item, index) => ({
+    id: `action_${index + 1}_${item.checkId}`,
+    title: item.action,
+    command: item.command,
+    rationale: `Doctor check ${item.checkId} is not passing.`,
+    mutability: item.command ? inferMutability(item.command) : "unknown",
+    requires_approval: item.command ? commandRequiresApproval(item.command) : true
+  }));
+}
+function nextCommandsForActions(actions, doctorNextCommands) {
+  const seen = new Set;
+  const commands = [
+    ...actions.map((action) => action.command).filter((command) => Boolean(command)),
+    ...doctorNextCommands
+  ].filter((command) => {
+    if (seen.has(command))
+      return false;
+    seen.add(command);
+    return true;
+  });
+  return commands.slice(0, 12).map((command) => ({
+    command,
+    purpose: purposeForCommand(command),
+    mutability: inferMutability(command),
+    requires_approval: commandRequiresApproval(command)
+  }));
+}
+function existingArtifacts(cwd) {
+  return [
+    [HARNESS_PATH, "harness_manifest", "Local harness graph manifest."],
+    [HARNESS_REPORT_PATH, "harness_report", "Cited harness analyst report."],
+    [HARNESS_REPORT_MARKDOWN_PATH, "harness_report_markdown", "Human-readable harness analyst report."],
+    [HARNESS_SUMMARY_PATH, "harness_summary", "Human-readable harness graph summary."],
+    [join(MODA_DIR, "sync-state.json"), "sync_state", "Last local harness sync state."],
+    [join(MODA_DIR, "prompts.yml"), "prompt_manifest", "Local prompt discovery manifest."]
+  ].flatMap(([path, kind, description]) => existsSync(join(cwd, path)) ? [{ path, kind, description }] : []);
+}
+function expandEvidenceRef(ref, loaded, cwd) {
+  if (ref.startsWith("doctor:")) {
+    const checkId = ref.slice("doctor:".length);
+    const check = loaded.doctor.checks.find((candidate) => candidate.id === checkId);
+    if (!check)
+      throw missingEvidence(ref);
+    return {
+      schemaVersion: "agent_evidence.v0.1",
+      ref: checkToEvidenceRef(check),
+      value: check
+    };
+  }
+  if (ref.startsWith("harness-report:claim:")) {
+    const claimId = ref.slice("harness-report:claim:".length);
+    const claim = loaded.report?.claims.find((candidate) => candidate.id === claimId);
+    if (!claim)
+      throw missingEvidence(ref);
+    return {
+      schemaVersion: "agent_evidence.v0.1",
+      ref: claimToEvidenceRef(claim),
+      value: claim,
+      artifact: { kind: "harness_report", path: HARNESS_REPORT_PATH }
+    };
+  }
+  if (ref.startsWith("harness-report:citation:")) {
+    const citationId = ref.slice("harness-report:citation:".length);
+    const citation = loaded.report?.citations.find((candidate) => candidate.id === citationId);
+    if (!citation)
+      throw missingEvidence(ref);
+    return {
+      schemaVersion: "agent_evidence.v0.1",
+      ref: citationToEvidenceRef(citation),
+      value: {
+        citation,
+        currentExcerpt: citation.path ? readCitationExcerpt(cwd, citation) : undefined
+      },
+      artifact: citation.path ? { kind: "citation_source", path: citation.path } : undefined
+    };
+  }
+  if (ref.startsWith("artifact:")) {
+    const path = ref.slice("artifact:".length);
+    const artifact = loaded.payload.artifacts.find((candidate) => candidate.path === path);
+    if (!artifact)
+      throw missingEvidence(ref);
+    return {
+      schemaVersion: "agent_evidence.v0.1",
+      ref: {
+        id: ref,
+        kind: artifact.kind,
+        label: artifact.description ?? artifact.path,
+        path: artifact.path
+      },
+      value: readModaArtifact(cwd, artifact.path),
+      artifact
+    };
+  }
+  throw missingEvidence(ref);
+}
+function claimToEvidenceRef(claim) {
+  return {
+    id: `harness-report:claim:${claim.id}`,
+    kind: "harness_claim",
+    label: claim.title,
+    status: claim.inference
+  };
+}
+function citationToEvidenceRef(citation) {
+  return {
+    id: `harness-report:citation:${citation.id}`,
+    kind: citation.type,
+    label: citation.reason,
+    path: citation.path,
+    line: citation.line
+  };
+}
+function readCitationExcerpt(cwd, citation) {
+  if (!citation.path || citation.type !== "file" && citation.type !== "generated_doc")
+    return citation.excerpt;
+  const absolute = safeResolve(cwd, citation.path);
+  if (!absolute || !existsSync(absolute))
+    return citation.excerpt;
+  const text = readFileSync(absolute, "utf8");
+  if (citation.line && citation.line > 0) {
+    return text.split(/\r?\n/)[citation.line - 1] ?? citation.excerpt;
+  }
+  return text;
+}
+function readModaArtifact(cwd, artifactPath) {
+  if (!artifactPath.startsWith(".moda/")) {
+    throw new CliInputError(`Artifact '${artifactPath}' is outside .moda and cannot be expanded directly.`, "Use a citation evidence ref for source-file evidence.");
+  }
+  const absolute = safeResolve(cwd, artifactPath);
+  if (!absolute || !existsSync(absolute))
+    throw missingEvidence(`artifact:${artifactPath}`);
+  const size = statSync(absolute).size;
+  return {
+    path: artifactPath,
+    bytes: size,
+    text: readFileSync(absolute, "utf8")
+  };
+}
+function safeResolve(cwd, path) {
+  const absolute = resolve(cwd, path);
+  const rel = relative(cwd, absolute);
+  if (rel.startsWith("..") || rel === ".." || rel.startsWith("/"))
+    return;
+  return absolute;
+}
+function missingEvidence(ref) {
+  return new CliInputError(`Evidence reference '${ref}' was not found.`, "Run `moda agent context` to list available evidence_refs.");
+}
+function inferMutability(command) {
+  if (/\bsync\b/.test(command))
+    return "sync";
+  if (/\b(init|install|approve|pull|gen|promote|remove)\b/.test(command))
+    return "write";
+  return "read";
+}
+function commandRequiresApproval(command) {
+  return inferMutability(command) !== "read" && !command.includes("--dry-run");
+}
+function purposeForCommand(command) {
+  if (command.includes("harness approve"))
+    return "Approve the current harness report after human review.";
+  if (command.includes("harness sync"))
+    return "Sync approved harness state to Moda Cloud.";
+  if (command.includes("harness analyze"))
+    return "Produce or refresh a cited harness report.";
+  if (command.includes("doctor"))
+    return "Re-run local diagnostics.";
+  if (command.includes("init"))
+    return "Complete local Moda onboarding.";
+  return "Inspect or repair local Moda state.";
+}
+export {
+  runAgentCommand
+};