@nick848/fet 1.1.0 → 1.1.2

package/dist/cli/index.js

@@ -5,7 +5,7 @@ import {
 } from "../chunk-J5WB4KAL.js";
 
 // src/cli/index.ts
-import { createInterface } from "readline/promises";
+import { createInterface as createInterface2 } from "readline/promises";
 import { Command } from "commander";
 
 // src/commands/doctor.ts
@@ -1575,6 +1575,7 @@ ${block}
 
 // src/commands/update-context.ts
 import { readFile as readFile7 } from "fs/promises";
+import { createInterface } from "readline/promises";
 import { join as join11 } from "path";
 
 // src/config/yaml.ts
@@ -1627,7 +1628,7 @@ async function updateContextFiles(ctx) {
     });
   }
   if (existingAgents && !hasManagedAutoRegion(existingAgents)) {
-    if (!ctx.yes) {
+    if (!ctx.yes && !await confirmInitCanReplaceUnmanagedAgents(ctx)) {
       throw new FetError({
         code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
         message: ctx.language === "en" ? "AGENTS.md already exists and does not contain a FET-managed region." : "AGENTS.md \u5DF2\u5B58\u5728\uFF0C\u4E14\u4E0D\u5305\u542B FET \u6258\u7BA1\u533A\u57DF\u3002",
@@ -1664,6 +1665,27 @@ async function updateContextFiles(ctx) {
   await ctx.stateStore.writeGlobal(state);
   return { warnings };
 }
+async function confirmInitCanReplaceUnmanagedAgents(ctx) {
+  if (ctx.command !== "init" || ctx.json || !process.stdin.isTTY || !process.stderr.isTTY) {
+    return false;
+  }
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  try {
+    const question = ctx.language === "en" ? "AGENTS.md already exists and is not managed by FET. Continue now with the same effect as fet init --yes? [y/N] " : "AGENTS.md \u5DF2\u5B58\u5728\u4E14\u4E0D\u7531 FET \u6258\u7BA1\u3002\u662F\u5426\u7EE7\u7EED\u6267\u884C\uFF0C\u6548\u679C\u7B49\u540C\u4E8E fet init --yes\uFF1F[y/N] ";
+    const answer = (await rl.question(question)).trim().toLowerCase();
+    if (answer === "y" || answer === "yes") {
+      return true;
+    }
+  } finally {
+    rl.close();
+  }
+  throw new FetError({
+    code: "USER_CANCELLED" /* UserCancelled */,
+    message: ctx.language === "en" ? "fet init cancelled so you can handle AGENTS.md manually." : "\u5DF2\u53D6\u6D88 fet init\uFF0C\u4F60\u53EF\u4EE5\u5148\u624B\u52A8\u5904\u7406 AGENTS.md\u3002",
+    details: { path: "AGENTS.md" },
+    suggestedCommand: ctx.language === "en" ? "Review AGENTS.md, then rerun fet init or fet init --yes." : "\u68C0\u67E5 AGENTS.md \u540E\uFF0C\u624B\u52A8\u91CD\u65B0\u8FD0\u884C fet init \u6216 fet init --yes\u3002"
+  });
+}
 async function readOptional2(path) {
   try {
     return await readFile7(path, "utf8");
@@ -1982,6 +2004,10 @@ var phaseByCommand = {
   onboard: "explore"
 };
 async function proxyCommand(ctx, command, args) {
+  if (command === "propose" || command === "continue" || command === "ff") {
+    await artifactWorkflowCommand(ctx, command, args);
+    return;
+  }
   const openSpecArgs = stripFetOptions(args);
   const runState = {};
   await withProjectLock(ctx.projectRoot, { command, cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
@@ -2056,6 +2082,225 @@ async function proxyCommand(ctx, command, args) {
     data: graphContext ? { graphContext } : void 0
   });
 }
+async function artifactWorkflowCommand(ctx, command, args) {
+  const openSpecArgs = stripFetOptions(args);
+  const runState = {};
+  await withProjectLock(ctx.projectRoot, { command, cwd: ctx.cwd, fetVersion: ctx.fetVersion }, async () => {
+    await assertOpenSpecCommandSupported(ctx, "status", command);
+    await assertOpenSpecCommandSupported(ctx, "instructions", command);
+    if (command === "propose") {
+      await assertOpenSpecCommandSupported(ctx, "new", command);
+    }
+    const changeId = command === "propose" ? await ensureProposedChange(ctx, openSpecArgs) : await requireChangeId(ctx);
+    const artifactId = command === "continue" ? await resolveArtifactId(ctx, changeId, openSpecArgs[0]) : await resolveArtifactId(ctx, changeId);
+    runState.graphContext = await buildWorkflowGraphContext(ctx, {
+      command,
+      args: artifactId ? [artifactId, "--change", changeId] : ["--change", changeId],
+      changeId
+    });
+    const instructions = await runInstructions(ctx, changeId, artifactId);
+    await syncWorkflowState(ctx, command, changeId, {
+      openSpecCommand: "instructions",
+      openSpecArgs: [artifactId, "--change", changeId],
+      exitCode: instructions.exitCode
+    });
+    const status = await readOpenSpecStatus(ctx, changeId);
+    ctx.output.result({
+      ok: true,
+      command,
+      summary: `fet ${command} prepared OpenSpec artifact "${artifactId}" for change "${changeId}".`,
+      warnings: runState.graphContext?.warnings,
+      nextSteps: [
+        `Create or update openspec/changes/${changeId}/${resolveOutputPath(status, artifactId)}`,
+        `Run fet passthrough status --change ${changeId}`,
+        status.isComplete ? `Run fet apply --change ${changeId}` : `Run fet continue --change ${changeId}`
+      ],
+      data: {
+        changeId,
+        artifactId,
+        instructions: instructions.data,
+        status,
+        graphContext: runState.graphContext
+      }
+    });
+  });
+}
+async function ensureProposedChange(ctx, args) {
+  if (ctx.changeId) {
+    return ctx.changeId;
+  }
+  const existing = await ctx.openSpec.inspectProject(ctx.projectRoot);
+  const explicit = args[0];
+  if (!explicit) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: "A change id or short description is required for fet propose.",
+      suggestedCommand: "fet propose <change-id-or-description>"
+    });
+  }
+  const input = args.join(" ").trim();
+  const changeId = isKebabId(input) ? input : toKebabId(input);
+  if (!changeId) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: "Unable to derive a valid OpenSpec change id from the proposal input.",
+      details: { input },
+      suggestedCommand: "fet propose <kebab-case-change-id>"
+    });
+  }
+  if (existing.changes.includes(changeId)) {
+    return changeId;
+  }
+  const createArgs = ["change", changeId];
+  if (input && input !== changeId) {
+    createArgs.push("--description", input);
+  }
+  const result = await ctx.openSpec.run("new", createArgs, { cwd: ctx.projectRoot, stdio: "pipe" });
+  if (result.exitCode !== 0) {
+    throw new FetError({
+      code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+      message: "OpenSpec new change failed.",
+      details: result,
+      recoverable: true
+    });
+  }
+  return changeId;
+}
+async function resolveArtifactId(ctx, changeId, requestedArtifactId) {
+  const status = await readOpenSpecStatus(ctx, changeId);
+  const artifacts = status.artifacts ?? [];
+  if (requestedArtifactId) {
+    const requested = artifacts.find((artifact) => artifact.id === requestedArtifactId);
+    if (!requested) {
+      throw new FetError({
+        code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+        message: `OpenSpec artifact "${requestedArtifactId}" was not found for change "${changeId}".`,
+        details: { changeId, requestedArtifactId, artifacts: artifacts.map((artifact) => artifact.id) },
+        suggestedCommand: `fet passthrough status --change ${changeId} --json`
+      });
+    }
+    if (requested.status !== "ready" && requested.status !== "complete") {
+      throw new FetError({
+        code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+        message: `OpenSpec artifact "${requestedArtifactId}" is ${requested.status}, not ready.`,
+        details: { changeId, requestedArtifactId, missingDeps: requested.missingDeps },
+        suggestedCommand: `fet continue --change ${changeId}`
+      });
+    }
+    return requestedArtifactId;
+  }
+  const next = artifacts.find((artifact) => artifact.status === "ready");
+  if (!next) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: `No ready OpenSpec artifact was found for change "${changeId}".`,
+      details: { changeId, artifacts },
+      suggestedCommand: status.isComplete ? `fet apply --change ${changeId}` : `fet passthrough status --change ${changeId} --json`
+    });
+  }
+  return next.id;
+}
+async function readOpenSpecStatus(ctx, changeId) {
+  const result = await ctx.openSpec.run("status", ["--change", changeId, "--json"], { cwd: ctx.projectRoot, stdio: "pipe" });
+  if (result.exitCode !== 0) {
+    throw new FetError({
+      code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+      message: "OpenSpec status failed.",
+      details: result,
+      recoverable: true
+    });
+  }
+  try {
+    return parseOpenSpecJson(result.stdout ?? "{}");
+  } catch (error) {
+    throw new FetError({
+      code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+      message: "Unable to parse OpenSpec status JSON.",
+      details: { stdout: result.stdout, stderr: result.stderr },
+      cause: error
+    });
+  }
+}
+async function runInstructions(ctx, changeId, artifactId) {
+  const args = [artifactId, "--change", changeId, ...ctx.json ? ["--json"] : []];
+  const result = await ctx.openSpec.run("instructions", args, { cwd: ctx.projectRoot, stdio: "pipe" });
+  if (result.stdout && !ctx.json) {
+    process.stdout.write(result.stdout.endsWith("\n") ? result.stdout : `${result.stdout}
+`);
+  }
+  if (result.stderr && !ctx.json) {
+    process.stderr.write(result.stderr.endsWith("\n") ? result.stderr : `${result.stderr}
+`);
+  }
+  if (result.exitCode !== 0) {
+    throw new FetError({
+      code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+      message: "OpenSpec instructions failed.",
+      details: result,
+      recoverable: true
+    });
+  }
+  if (!ctx.json) {
+    return { exitCode: result.exitCode, data: null };
+  }
+  try {
+    return { exitCode: result.exitCode, data: parseOpenSpecJson(result.stdout ?? "{}") };
+  } catch (error) {
+    throw new FetError({
+      code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+      message: "Unable to parse OpenSpec instructions JSON.",
+      details: { stdout: result.stdout, stderr: result.stderr },
+      cause: error
+    });
+  }
+}
+async function syncWorkflowState(ctx, command, changeId, lastOpenSpecCommand) {
+  const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
+  const state = await ctx.stateStore.getOrCreateGlobal();
+  state.openChangeIds = inspection.changes;
+  if (inspection.changes.includes(changeId)) {
+    state.activeChangeId = changeId;
+  }
+  await ctx.stateStore.writeGlobal(state);
+  if (!inspection.changes.includes(changeId)) {
+    return;
+  }
+  const changeInspection = await ctx.openSpec.inspectChange(ctx.projectRoot, changeId);
+  const changeState = await ctx.stateStore.getOrCreateChange(changeId, phaseByCommand[command] ?? "propose");
+  changeState.currentPhase = "propose";
+  changeState.phases.propose = {
+    status: "in_progress",
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  changeState.lastOpenSpecCommand = {
+    command: lastOpenSpecCommand.openSpecCommand,
+    args: lastOpenSpecCommand.openSpecArgs,
+    exitCode: lastOpenSpecCommand.exitCode,
+    ranAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  changeState.tasks.completedIds = await readCompletedTaskIds(changeInspection.tasksPath);
+  changeState.tasks.lastSyncedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await ctx.stateStore.writeChange(changeState);
+}
+function resolveOutputPath(status, artifactId) {
+  return status.artifacts?.find((artifact) => artifact.id === artifactId)?.outputPath ?? `${artifactId}.md`;
+}
+function isKebabId(value) {
+  return /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+}
+function toKebabId(value) {
+  return value.trim().toLowerCase().replace(/['"]/g, "").replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function parseOpenSpecJson(stdout) {
+  const trimmed = stdout.trim();
+  const objectStart = trimmed.indexOf("{");
+  const arrayStart = trimmed.indexOf("[");
+  const starts = [objectStart, arrayStart].filter((index) => index >= 0);
+  if (!starts.length) {
+    return JSON.parse(trimmed || "{}");
+  }
+  return JSON.parse(trimmed.slice(Math.min(...starts)));
+}
 async function assertOpenSpecCommandSupported(ctx, openSpecCommand, fetCommand) {
   const capabilities = await ctx.openSpec.getCapabilities();
   if (capabilities.commands.includes(openSpecCommand)) {
@@ -4192,6 +4437,10 @@ var DefaultOpenSpecAdapter = class {
 function parseCommands(help) {
   const known = [
     "init",
+    "update",
+    "list",
+    "view",
+    "change",
     "explore",
     "propose",
     "new",
@@ -4202,7 +4451,18 @@ function parseCommands(help) {
     "sync",
     "archive",
     "bulk-archive",
-    "onboard"
+    "onboard",
+    "spec",
+    "config",
+    "schema",
+    "validate",
+    "show",
+    "feedback",
+    "completion",
+    "status",
+    "instructions",
+    "templates",
+    "schemas"
   ];
   return known.filter((command) => new RegExp(`\\b${escapeRegExp(command)}\\b`).test(help));
 }
@@ -4599,7 +4859,7 @@ async function handleModelPolicyRecommendation(ctx) {
   if (policyMode !== "confirm" || ctx.yes || ctx.json || !process.stdin.isTTY || !process.stderr.isTTY) {
     return;
   }
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
   try {
     const question = ctx.language === "en" ? "Continue anyway? [y/N] " : "\u4ECD\u7136\u7EE7\u7EED\uFF1F[y/N] ";
     const answer = (await rl.question(question)).trim().toLowerCase();