@mandujs/core 0.54.2 → 0.54.4

package/src/agent/plan.ts

@@ -0,0 +1,283 @@
+import fs from "fs/promises";
+import path from "path";
+import type {
+  AgentApplyReport,
+  AgentDomain,
+  AgentPlan,
+  AgentPlanRisk,
+  AgentSuggestedCommand,
+  BuildAgentApplyOptions,
+  BuildAgentPlanOptions,
+} from "./types";
+
+const DEFAULT_PLAN_PATH = ".mandu/agent-plan.json";
+
+const DOMAIN_KEYWORDS: Array<[AgentDomain, RegExp]> = [
+  ["hydration", /\b(hydrat|island|partial|client|counter|interactive|ssr data)\b/i],
+  ["contract", /\b(contract|openapi|schema|typed api|rpc)\b/i],
+  ["api", /\b(api|endpoint|route handler|server action|post|get|put|delete)\b/i],
+  ["slot", /\b(slot|filling|ctx\.|handler chain)\b/i],
+  ["guard", /\b(guard|architecture|import boundary|layer|rule)\b/i],
+  ["testing", /\b(test|spec|coverage|ate|e2e|playwright)\b/i],
+  ["deploy", /\b(deploy|vercel|netlify|fly|render|docker|worker|edge)\b/i],
+  ["design", /\b(design|ui|component|style|theme|tailwind|shadcn)\b/i],
+  ["docs", /\b(doc|readme|guide|manual|changelog)\b/i],
+  ["db", /\b(database|db|migration|seed|sqlite|postgres)\b/i],
+  ["route", /\b(page|route|dashboard|screen|layout|fs route)\b/i],
+];
+
+function unique<T>(values: T[]): T[] {
+  return [...new Set(values)];
+}
+
+function inferDomains(intent: string): AgentDomain[] {
+  const domains = DOMAIN_KEYWORDS
+    .filter(([, pattern]) => pattern.test(intent))
+    .map(([domain]) => domain);
+
+  if (domains.includes("api") && !domains.includes("contract")) {
+    domains.push("contract");
+  }
+  if (domains.includes("hydration") && !domains.includes("route")) {
+    domains.push("route");
+  }
+  if (domains.length === 0) {
+    domains.push("unknown");
+  }
+  return unique(domains);
+}
+
+function filesToRead(domains: AgentDomain[]): string[] {
+  const out: string[] = ["docs/plans/20_agent_surface_consolidation_plan.md"];
+  if (domains.includes("route")) out.push("app/", ".mandu/routes.manifest.json");
+  if (domains.includes("api")) out.push("app/api/", "spec/contracts/");
+  if (domains.includes("contract")) out.push("spec/contracts/", "docs/resource-architecture.md");
+  if (domains.includes("slot")) out.push("spec/slots/", "packages/mcp/src/resources/skills/mandu-slot/SKILL.md");
+  if (domains.includes("hydration")) out.push("packages/mcp/src/resources/skills/mandu-hydration/SKILL.md", "app/**/*.partial.tsx");
+  if (domains.includes("guard")) out.push("mandu.config.ts", "packages/mcp/src/resources/skills/mandu-guard/SKILL.md");
+  if (domains.includes("testing")) out.push("packages/mcp/src/resources/skills/mandu-testing/SKILL.md");
+  if (domains.includes("deploy")) out.push(".mandu/deploy.intent.json", "docs/deploy/README.md");
+  if (domains.includes("design")) out.push("DESIGN.md", "packages/mcp/src/resources/skills/mandu-ui/SKILL.md");
+  if (domains.includes("db")) out.push("spec/resources/", "spec/migrations/");
+  return unique(out);
+}
+
+function filesToCreate(intent: string, domains: AgentDomain[]): string[] {
+  const lower = intent.toLowerCase();
+  const out: string[] = [];
+  if (domains.includes("route")) {
+    if (lower.includes("dashboard")) out.push("app/dashboard/page.tsx");
+    else out.push("app/<route>/page.tsx");
+  }
+  if (domains.includes("api")) out.push("app/api/<name>/route.ts");
+  if (domains.includes("contract")) out.push("spec/contracts/<name>.contract.ts");
+  if (domains.includes("slot")) out.push("spec/slots/<name>.slot.ts");
+  if (domains.includes("hydration")) out.push("app/<route>/<component>.partial.tsx");
+  if (domains.includes("testing")) out.push("packages/<target>/__tests__/<feature>.test.ts");
+  if (domains.includes("docs")) out.push("docs/<topic>.md");
+  return unique(out);
+}
+
+function mcpTools(domains: AgentDomain[]): string[] {
+  const out = ["mandu.agent.context", "mandu.agent.verify"];
+  if (domains.includes("route")) out.push("mandu.route.list", "mandu.generate");
+  if (domains.includes("api")) out.push("mandu.generate", "mandu.contract.create");
+  if (domains.includes("contract")) out.push("mandu.contract.validate", "mandu.contract.openapi");
+  if (domains.includes("slot")) out.push("mandu.slot.validate", "mandu.slot.constraints");
+  if (domains.includes("hydration")) out.push("mandu.island.list", "mandu.hydration.set");
+  if (domains.includes("guard")) out.push("mandu.guard.check", "mandu.guard.explain");
+  if (domains.includes("testing")) out.push("mandu.run.tests", "mandu.ate.generate");
+  if (domains.includes("deploy")) out.push("mandu.deploy.plan", "mandu.deploy.compile");
+  if (domains.includes("design")) out.push("mandu.design.get", "mandu.design.check");
+  return unique(out);
+}
+
+function risks(domains: AgentDomain[]): AgentPlanRisk[] {
+  const out: AgentPlanRisk[] = [];
+  if (domains.includes("db")) out.push({ level: "high", reason: "Database changes can affect persistent data." });
+  if (domains.includes("deploy")) out.push({ level: "high", reason: "Deploy artifacts may affect production behavior." });
+  if (domains.includes("guard")) out.push({ level: "medium", reason: "Architecture rule changes can hide future violations." });
+  if (domains.includes("hydration")) out.push({ level: "medium", reason: "SSR/client boundaries can regress hydration." });
+  if (domains.includes("api") || domains.includes("contract")) {
+    out.push({ level: "medium", reason: "API and contract changes must stay synchronized." });
+  }
+  if (out.length === 0) out.push({ level: "low", reason: "No high-risk domain detected by deterministic planner." });
+  return out;
+}
+
+function verification(domains: AgentDomain[]): AgentSuggestedCommand[] {
+  const out: AgentSuggestedCommand[] = [
+    {
+      command: "mandu agent verify --changed --json --write",
+      reason: "Canonical post-change verification gate.",
+      required: true,
+    },
+    {
+      command: "bun run typecheck",
+      reason: "Type boundary check for generated or edited TypeScript.",
+      required: true,
+    },
+  ];
+  if (domains.includes("hydration") || domains.includes("route")) {
+    out.push({
+      command: "bun test packages/core/src/bundler packages/core/tests/client",
+      reason: "Route and hydration changes can affect bundling and client runtime.",
+      required: true,
+    });
+  }
+  if (domains.includes("api") || domains.includes("contract") || domains.includes("slot")) {
+    out.push({
+      command: "bun test packages/core/src/contract packages/core/src/slot packages/core/tests/routes",
+      reason: "API, contract, and slot changes need framework contract coverage.",
+      required: true,
+    });
+  }
+  if (domains.includes("deploy")) {
+    out.push({
+      command: "mandu deploy:plan --dry-run",
+      reason: "Deploy intent should be inspected before writing provider artifacts.",
+      required: true,
+    });
+  }
+  return unique(out.map((item) => JSON.stringify(item))).map((item) => JSON.parse(item) as AgentSuggestedCommand);
+}
+
+export function buildAgentPlan(options: BuildAgentPlanOptions): AgentPlan {
+  const intent = options.intent.trim();
+  const domains = inferDomains(intent);
+  return {
+    schemaVersion: 1,
+    framework: "mandu",
+    generatedAt: new Date().toISOString(),
+    intent,
+    domains,
+    filesToRead: filesToRead(domains),
+    filesToCreate: filesToCreate(intent, domains),
+    filesToModify: [],
+    mcpTools: mcpTools(domains),
+    risks: risks(domains),
+    verification: verification(domains),
+    notes: [
+      "This deterministic plan is intentionally conservative. It does not execute edits.",
+      "Prefer MCP/domain tools before direct file edits, then run agent verify.",
+    ],
+    executable: false,
+  };
+}
+
+export function agentPlanPath(rootDir: string): string {
+  return path.join(rootDir, ".mandu", "agent-plan.json");
+}
+
+export async function writeAgentPlan(rootDir: string, plan: AgentPlan): Promise<{ path: string; plan: AgentPlan }> {
+  const outPath = agentPlanPath(rootDir);
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.writeFile(outPath, `${JSON.stringify(plan, null, 2)}\n`, "utf8");
+  return { path: outPath, plan };
+}
+
+async function readAgentPlan(filePath: string): Promise<AgentPlan | null> {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw) as AgentPlan;
+    if (parsed?.framework !== "mandu" || !Array.isArray(parsed.domains)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function resolveInside(rootDir: string, value: string): string {
+  const root = path.resolve(rootDir);
+  const resolved = path.resolve(root, value);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+    throw new Error("agent apply input must stay inside the project root");
+  }
+  return resolved;
+}
+
+export async function buildAgentApplyReport(
+  rootDir: string = process.cwd(),
+  options: BuildAgentApplyOptions = {},
+): Promise<AgentApplyReport> {
+  const sourceRel = options.from ?? DEFAULT_PLAN_PATH;
+  const sourcePath = resolveInside(rootDir, sourceRel);
+  const plan = await readAgentPlan(sourcePath);
+  if (!plan) {
+    return {
+      schemaVersion: 1,
+      framework: "mandu",
+      generatedAt: new Date().toISOString(),
+      ok: false,
+      dryRun: true,
+      sourcePlan: sourceRel,
+      intent: "",
+      domains: ["unknown"],
+      actions: [
+        {
+          kind: "verify",
+          description: "Create an agent plan first.",
+          command: "mandu agent plan \"<task>\" --json --write",
+          applied: false,
+        },
+      ],
+      warnings: [`Could not read ${sourceRel}.`],
+      nextVerifyCommand: "mandu agent verify --changed --json --write",
+    };
+  }
+
+  return {
+    schemaVersion: 1,
+    framework: "mandu",
+    generatedAt: new Date().toISOString(),
+    ok: true,
+    dryRun: options.dryRun !== false,
+    sourcePlan: sourceRel,
+    intent: plan.intent,
+    domains: plan.domains,
+    actions: [
+      ...plan.filesToRead.map((file) => ({
+        kind: "read_file" as const,
+        description: `Read ${file} before editing.`,
+        file,
+        applied: false as const,
+      })),
+      ...plan.mcpTools.map((tool) => ({
+        kind: "mcp_tool" as const,
+        description: `Consider ${tool} for this plan.`,
+        tool,
+        applied: false as const,
+      })),
+      ...plan.filesToCreate.map((file) => ({
+        kind: "manual_edit" as const,
+        description: `Create ${file} only after confirming the local pattern.`,
+        file,
+        applied: false as const,
+      })),
+      ...plan.verification.map((item) => ({
+        kind: "verify" as const,
+        description: item.reason,
+        command: item.command,
+        applied: false as const,
+      })),
+    ],
+    warnings: [
+      "Agent apply is dry-run only until typed operation payloads are introduced.",
+      "No filesystem changes were made by this report.",
+    ],
+    nextVerifyCommand: "mandu agent verify --changed --json --write",
+  };
+}
+
+export async function writeAgentApplyReport(
+  rootDir: string,
+  report: AgentApplyReport,
+): Promise<{ path: string; report: AgentApplyReport }> {
+  const outPath = path.join(rootDir, ".mandu", "agent-apply.json");
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.writeFile(outPath, `${JSON.stringify(report, null, 2)}\n`, "utf8");
+  return { path: outPath, report };
+}
+

package/src/agent/repair.ts

@@ -0,0 +1,172 @@
+import fs from "fs/promises";
+import path from "path";
+import type {
+  AgentDiagnostic,
+  AgentRepairAction,
+  AgentRepairReport,
+  AgentVerifyReport,
+  BuildAgentRepairOptions,
+} from "./types";
+
+const DEFAULT_VERIFY_INPUT = ".mandu/agent-verify.json";
+
+function resolveInside(rootDir: string, value: string): string {
+  const root = path.resolve(rootDir);
+  const resolved = path.resolve(root, value);
+  if (resolved !== root && !resolved.startsWith(root + path.sep)) {
+    throw new Error("repair input must stay inside the project root");
+  }
+  return resolved;
+}
+
+async function readVerifyReport(filePath: string): Promise<AgentVerifyReport | null> {
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const parsed = JSON.parse(raw) as AgentVerifyReport;
+    if (parsed?.framework !== "mandu" || !Array.isArray(parsed.diagnostics)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+
+function actionForDiagnostic(diagnostic: AgentDiagnostic): AgentRepairAction {
+  const fix = diagnostic.suggestedFix;
+  if (!fix) {
+    return {
+      diagnosticCode: diagnostic.code,
+      kind: "manual",
+      description: `Inspect ${diagnostic.code}: ${diagnostic.cause}`,
+      safeToApply: false,
+      applied: false,
+    };
+  }
+
+  if (fix.type === "run_command" && fix.command) {
+    return {
+      diagnosticCode: diagnostic.code,
+      kind: "run_command",
+      description: fix.description,
+      command: fix.command,
+      safeToApply: false,
+      applied: false,
+    };
+  }
+
+  if ((fix.type === "create_file" || fix.type === "modify_file") && fix.path) {
+    return {
+      diagnosticCode: diagnostic.code,
+      kind: "patch",
+      description: fix.description,
+      file: fix.path,
+      // Current diagnostic shape does not carry patch content. Keep this
+      // conservative until a typed patch payload exists.
+      safeToApply: false,
+      applied: false,
+    };
+  }
+
+  return {
+    diagnosticCode: diagnostic.code,
+    kind: "manual",
+    description: fix.description,
+    safeToApply: false,
+    applied: false,
+  };
+}
+
+export function agentRepairReportPath(rootDir: string): string {
+  return path.join(rootDir, ".mandu", "agent-repair.json");
+}
+
+export async function buildAgentRepairReport(
+  rootDir: string = process.cwd(),
+  options: BuildAgentRepairOptions = {},
+): Promise<AgentRepairReport> {
+  const root = path.resolve(rootDir);
+  const sourceRel = options.from ?? DEFAULT_VERIFY_INPUT;
+  const sourcePath = resolveInside(root, sourceRel);
+  const warnings: string[] = [];
+  const report = await readVerifyReport(sourcePath);
+
+  if (!report) {
+    return {
+      schemaVersion: 1,
+      framework: "mandu",
+      generatedAt: new Date().toISOString(),
+      ok: false,
+      status: "input_missing",
+      sourceReport: sourceRel,
+      diagnostics: [
+        {
+          code: "MANDU_REPAIR_INPUT_MISSING",
+          severity: "error",
+          title: "Agent verify report missing",
+          cause: `Could not read ${sourceRel}.`,
+          suggestedFix: {
+            type: "run_command",
+            command: "mandu agent verify --changed --json --write",
+            description: "Generate a fresh agent verify report first.",
+          },
+          docs: "docs/plans/20_agent_surface_consolidation_plan.md",
+          repairable: true,
+          source: "agent.repair",
+        },
+      ],
+      actions: [
+        {
+          diagnosticCode: "MANDU_REPAIR_INPUT_MISSING",
+          kind: "run_command",
+          description: "Generate a fresh agent verify report first.",
+          command: "mandu agent verify --changed --json --write",
+          safeToApply: false,
+          applied: false,
+        },
+      ],
+      appliedActions: [],
+      warnings: [],
+      nextVerifyCommand: "mandu agent verify --changed --json --write",
+    };
+  }
+
+  const diagnostics = report.diagnostics;
+  const actions = diagnostics.map(actionForDiagnostic);
+  const appliedActions: AgentRepairAction[] = [];
+
+  if (options.apply) {
+    const safePatchActions = actions.filter((action) => action.kind === "patch" && action.safeToApply);
+    if (safePatchActions.length === 0) {
+      warnings.push("No safe file patch candidates were available to apply.");
+    }
+    // Future extension: apply typed patch payloads here. Command execution is
+    // intentionally never auto-applied by repair.
+  }
+
+  return {
+    schemaVersion: 1,
+    framework: "mandu",
+    generatedAt: new Date().toISOString(),
+    ok: true,
+    status: diagnostics.length === 0 ? "nothing_to_repair" : "ready",
+    sourceReport: sourceRel,
+    diagnostics,
+    actions,
+    appliedActions,
+    warnings,
+    nextVerifyCommand: "mandu agent verify --changed --json --write",
+  };
+}
+
+export async function writeAgentRepairReport(
+  rootDir: string = process.cwd(),
+  report?: AgentRepairReport,
+): Promise<{ path: string; report: AgentRepairReport }> {
+  const value = report ?? await buildAgentRepairReport(rootDir);
+  const outPath = agentRepairReportPath(rootDir);
+  await fs.mkdir(path.dirname(outPath), { recursive: true });
+  await fs.writeFile(outPath, `${JSON.stringify(value, null, 2)}\n`, "utf8");
+  return { path: outPath, report: value };
+}
+

package/src/agent/sync.ts

@@ -0,0 +1,200 @@
+import fs from "fs/promises";
+import path from "path";
+import type {
+  AgentSuggestedCommand,
+  AgentSyncFile,
+  AgentSyncReport,
+  AgentSyncTarget,
+  BuildAgentSyncOptions,
+} from "./types";
+
+const SYNC_ROOT = path.join(".mandu", "agent-sync");
+const TARGETS = ["codex", "claude", "gemini"] as const;
+type ConcreteTarget = (typeof TARGETS)[number];
+
+function toPosix(value: string): string {
+  return value.split(path.sep).join("/");
+}
+
+function isTarget(value: string | undefined): value is AgentSyncTarget {
+  return value === "codex" || value === "claude" || value === "gemini" || value === "all";
+}
+
+function concreteTargets(target: AgentSyncTarget): ConcreteTarget[] {
+  return target === "all" ? [...TARGETS] : [target];
+}
+
+function targetFile(target: ConcreteTarget): string {
+  if (target === "codex") return path.join(SYNC_ROOT, "codex", "AGENTS.md");
+  if (target === "claude") return path.join(SYNC_ROOT, "claude", "CLAUDE.md");
+  return path.join(SYNC_ROOT, "gemini", "GEMINI.md");
+}
+
+function renderInstructions(target: ConcreteTarget): string {
+  const title =
+    target === "codex"
+      ? "Codex"
+      : target === "claude"
+        ? "Claude Code"
+        : "Gemini CLI";
+  return [
+    `# Mandu Agent Workflow for ${title}`,
+    "",
+    "Mandu is an agent-native fullstack framework. Use the official agent surface before direct source edits.",
+    "",
+    "## Canonical Loop",
+    "",
+    "```text",
+    "context -> plan -> apply -> verify -> repair",
+    "```",
+    "",
+    "## Required First Choices",
+    "",
+    "1. Start with `mandu.agent.context` or `mandu agent context --json`.",
+    "2. Create a plan with `mandu.agent.plan` or `mandu agent plan \"<task>\" --json --write`.",
+    "3. Prefer `mandu.agent.apply` and domain MCP tools before direct file edits.",
+    "4. End code-changing work with `mandu.agent.verify` or `mandu agent verify --changed --json --write`.",
+    "5. If verification fails, run `mandu.agent.repair` or `mandu agent repair --from .mandu/agent-verify.json --json`, then verify again.",
+    "",
+    "## MCP Profile",
+    "",
+    "Use the reduced default profile:",
+    "",
+    "```bash",
+    "MANDU_MCP_PROFILE=agent-core",
+    "```",
+    "",
+    "Escalate to `agent-full` only when the plan selects route, API, slot, hydration, contract, guard, testing, or lint domains. Use `internal` only for framework maintenance.",
+    "",
+    "## Domain Skill Escalation",
+    "",
+    "- route/api: `mandu-fs-routes`",
+    "- hydration/island/partial: `mandu-hydration`",
+    "- slot/filling: `mandu-slot`",
+    "- guard/import boundary: `mandu-guard`",
+    "- test/e2e/ATE: `mandu-testing`",
+    "- deploy: `mandu-deployment`",
+    "- security/auth/session: `mandu-security`",
+    "- styling/ui/design: `mandu-styling`, `mandu-ui`, `mandu-composition`",
+    "",
+    "Domain skills are addenda. They do not replace the canonical loop.",
+    "",
+  ].join("\n");
+}
+
+function renderClaudeSkill(): string {
+  return [
+    "---",
+    "name: mandu-agent-workflow",
+    "description: Canonical context -> plan -> apply -> verify -> repair workflow for Mandu projects.",
+    "---",
+    "",
+    "# Mandu Agent Workflow",
+    "",
+    "Use this skill first in Mandu projects. Follow `context -> plan -> apply -> verify -> repair`.",
+    "",
+    "Preferred tools: `mandu.agent.context`, `mandu.agent.plan`, `mandu.agent.apply`, `mandu.agent.verify`, `mandu.agent.repair`.",
+    "",
+    "CLI fallback:",
+    "",
+    "```bash",
+    "mandu agent context --json",
+    "mandu agent plan \"<task>\" --json --write",
+    "mandu agent apply --from .mandu/agent-plan.json --json",
+    "mandu agent verify --changed --json --write",
+    "mandu agent repair --from .mandu/agent-verify.json --json",
+    "```",
+    "",
+  ].join("\n");
+}
+
+function syncEntries(target: ConcreteTarget): Array<{ target: ConcreteTarget; relPath: string; content: string }> {
+  const entries = [
+    {
+      target,
+      relPath: targetFile(target),
+      content: renderInstructions(target),
+    },
+  ];
+  if (target === "claude") {
+    entries.push({
+      target,
+      relPath: path.join(SYNC_ROOT, "claude", "skills", "mandu-agent-workflow", "SKILL.md"),
+      content: renderClaudeSkill(),
+    });
+  }
+  return entries;
+}
+
+async function writeEntry(
+  rootDir: string,
+  entry: { target: ConcreteTarget; relPath: string; content: string },
+  dryRun: boolean,
+): Promise<AgentSyncFile> {
+  const absPath = path.join(rootDir, entry.relPath);
+  let action: AgentSyncFile["action"] = "created";
+  try {
+    const existing = await fs.readFile(absPath, "utf8");
+    action = existing === entry.content ? "unchanged" : "updated";
+  } catch {
+    action = "created";
+  }
+
+  if (dryRun) {
+    action = "planned";
+  } else if (action !== "unchanged") {
+    await fs.mkdir(path.dirname(absPath), { recursive: true });
+    await fs.writeFile(absPath, entry.content, "utf8");
+  }
+
+  return {
+    target: entry.target,
+    path: toPosix(entry.relPath),
+    action,
+    bytes: Buffer.byteLength(entry.content, "utf8"),
+  };
+}
+
+function nextCommands(): AgentSuggestedCommand[] {
+  return [
+    {
+      command: "mandu agent context --json",
+      reason: "Confirm the generated workflow matches the current project state.",
+      required: true,
+    },
+    {
+      command: "MANDU_MCP_PROFILE=agent-core",
+      reason: "Use the reduced default MCP exposure for coding agents.",
+      required: true,
+    },
+  ];
+}
+
+export async function buildAgentSyncReport(
+  rootDir: string = process.cwd(),
+  options: BuildAgentSyncOptions = {},
+): Promise<AgentSyncReport> {
+  const target = isTarget(options.target) ? options.target : "all";
+  const dryRun = options.dryRun === true;
+  const root = path.resolve(rootDir);
+  const files: AgentSyncFile[] = [];
+
+  for (const concrete of concreteTargets(target)) {
+    for (const entry of syncEntries(concrete)) {
+      files.push(await writeEntry(root, entry, dryRun));
+    }
+  }
+
+  return {
+    schemaVersion: 1,
+    framework: "mandu",
+    generatedAt: new Date().toISOString(),
+    ok: true,
+    target,
+    profile: "agent-core",
+    workflow: ["context", "plan", "apply", "verify", "repair"],
+    files,
+    warnings: dryRun ? ["Dry-run only. No files were written."] : [],
+    nextCommands: nextCommands(),
+  };
+}