@nick848/fet 0.1.0 → 1.0.1

package/dist/cli/index.js

@@ -0,0 +1,1816 @@
+#!/usr/bin/env node
+import {
+  FetError,
+  toFetError
+} from "../chunk-FZOVNHE7.js";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { readFile as readFile5, stat as stat2 } from "fs/promises";
+import { join as join6 } from "path";
+
+// src/fs/atomic-write.ts
+import { dirname } from "path";
+import { open, rename, mkdir } from "fs/promises";
+async function atomicWrite(targetPath, content) {
+  await mkdir(dirname(targetPath), { recursive: true });
+  const tempPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
+  const handle = await open(tempPath, "wx");
+  try {
+    await handle.writeFile(content);
+    await handle.sync();
+  } finally {
+    await handle.close();
+  }
+  await rename(tempPath, targetPath);
+  return { path: targetPath, tempPath };
+}
+
+// src/fs/backup.ts
+import { copyFile, stat } from "fs/promises";
+import { basename, dirname as dirname2, join } from "path";
+async function createBackup(filePath) {
+  try {
+    await stat(filePath);
+  } catch {
+    return null;
+  }
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[-:]/g, "").replace(/\..+$/, "").replace("T", "-");
+  const backupPath = join(dirname2(filePath), `${basename(filePath)}.fet-backup-${timestamp}`);
+  await copyFile(filePath, backupPath);
+  return backupPath;
+}
+
+// src/fs/lock.ts
+import { hostname } from "os";
+import { dirname as dirname3, join as join2 } from "path";
+import { mkdir as mkdir2, open as open2, readFile, rm } from "fs/promises";
+async function withProjectLock(projectRoot, metadata, fn) {
+  const lockPath = join2(projectRoot, "openspec", ".fet.lock");
+  const lock = {
+    pid: process.pid,
+    hostname: hostname(),
+    cwd: metadata.cwd,
+    command: metadata.command,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    fetVersion: metadata.fetVersion
+  };
+  let handle;
+  try {
+    await mkdir2(dirname3(lockPath), { recursive: true });
+    handle = await open2(lockPath, "wx");
+    await handle.writeFile(JSON.stringify(lock, null, 2));
+  } catch {
+    throw new FetError({
+      code: "LOCK_HELD" /* LockHeld */,
+      message: "\u53E6\u4E00\u4E2A FET \u5199\u547D\u4EE4\u6B63\u5728\u8FD0\u884C",
+      details: await readExistingLock(lockPath),
+      suggestedCommand: "fet doctor --fix-lock"
+    });
+  } finally {
+    await handle?.close();
+  }
+  try {
+    return await fn();
+  } finally {
+    await rm(lockPath, { force: true });
+  }
+}
+async function readExistingLock(lockPath) {
+  try {
+    return JSON.parse(await readFile(lockPath, "utf8"));
+  } catch {
+    return { path: lockPath };
+  }
+}
+async function clearLock(projectRoot) {
+  const lockPath = join2(projectRoot, "openspec", ".fet.lock");
+  try {
+    await rm(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/fs/journal.ts
+import { join as join3 } from "path";
+import { readFile as readFile2 } from "fs/promises";
+function createInitJournal(fetVersion) {
+  return {
+    schemaVersion: 1,
+    startedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    completedAt: null,
+    fetVersion,
+    steps: []
+  };
+}
+async function writeInitJournal(projectRoot, journal) {
+  await atomicWrite(
+    join3(projectRoot, "openspec", ".fet-init-journal.json"),
+    `${JSON.stringify(journal, null, 2)}
+`
+  );
+}
+
+// src/version.ts
+import { existsSync, readFileSync } from "fs";
+import { dirname as dirname4, join as join4, parse } from "path";
+import { fileURLToPath } from "url";
+var FET_VERSION = readPackageVersion();
+function readPackageVersion() {
+  let currentDir = dirname4(fileURLToPath(import.meta.url));
+  const root = parse(currentDir).root;
+  while (true) {
+    const packageJsonPath = join4(currentDir, "package.json");
+    if (existsSync(packageJsonPath)) {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+      if (typeof packageJson.version === "string" && packageJson.version.length > 0) {
+        return packageJson.version;
+      }
+      throw new Error(`package.json \u7F3A\u5C11\u6709\u6548\u7684 version \u5B57\u6BB5: ${packageJsonPath}`);
+    }
+    if (currentDir === root) {
+      throw new Error("\u65E0\u6CD5\u5B9A\u4F4D FET package.json");
+    }
+    currentDir = dirname4(currentDir);
+  }
+}
+
+// src/templates/markers.ts
+var AUTO_BEGIN = "<!-- FET:BEGIN AUTO -->";
+var AUTO_END = "<!-- FET:END AUTO -->";
+var USER_BEGIN = "<!-- FET:BEGIN USER -->";
+var USER_END = "<!-- FET:END USER -->";
+function hasManagedAutoRegion(content) {
+  return count(content, AUTO_BEGIN) === 1 && count(content, AUTO_END) === 1 && content.indexOf(AUTO_BEGIN) < content.indexOf(AUTO_END);
+}
+function hasInvalidManagedAutoRegion(content) {
+  const beginCount = count(content, AUTO_BEGIN);
+  const endCount = count(content, AUTO_END);
+  return beginCount !== endCount || beginCount > 1 || endCount > 1 || beginCount === 1 && content.indexOf(AUTO_BEGIN) > content.indexOf(AUTO_END);
+}
+function replaceManagedRegion(existing, generated) {
+  if (!existing) {
+    return generated;
+  }
+  const start = existing.indexOf(AUTO_BEGIN);
+  const end = existing.indexOf(AUTO_END);
+  if (start === -1 || end === -1 || end < start) {
+    return generated;
+  }
+  const before = existing.slice(0, start);
+  const after = existing.slice(end + AUTO_END.length);
+  const generatedAuto = extractAuto(generated);
+  return `${before}${AUTO_BEGIN}
+${generatedAuto}
+${AUTO_END}${after}`;
+}
+function extractAuto(content) {
+  const start = content.indexOf(AUTO_BEGIN);
+  const end = content.indexOf(AUTO_END);
+  if (start === -1 || end === -1 || end < start) {
+    return content.trim();
+  }
+  return content.slice(start + AUTO_BEGIN.length, end).trim();
+}
+function count(content, needle) {
+  return content.split(needle).length - 1;
+}
+
+// src/templates/agents-md.ts
+function renderAgentsMd(scan) {
+  const commands2 = Object.entries(scan.commands).map(([name, command]) => `| ${name} | \`${command.command}\` | ${command.source} |`).join("\n");
+  const routes = scan.routes.map((route) => `| ${route.path} | ${route.source} | ${route.confidence}${route.inferred ? " inferred" : ""} |`).join("\n");
+  const workspaces = scan.project.workspaces.map((workspace) => `| ${workspace.name} | ${workspace.path} | ${workspace.source} |`).join("\n");
+  return `# Project Context
+
+${AUTO_BEGIN}
+## Project Snapshot
+
+- Name: ${scan.project.name}
+- Package Manager: ${scan.project.packageManager} (${scan.project.packageManagerConfidence})
+- Framework: ${scan.project.framework.name} (${scan.project.framework.confidence})
+- Language: ${scan.project.language}
+- Monorepo: ${scan.project.monorepo ? "yes" : "no"}
+
+## Workspaces
+
+| Name | Path | Source |
+|------|------|--------|
+${workspaces || "| root | . | inferred |"}
+
+## Commands
+
+| Name | Command | Source |
+|------|---------|--------|
+${commands2 || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | [NEEDS LLM INPUT] |"}
+
+## Structure
+
+[NEEDS LLM INPUT]
+
+## Routes
+
+| Route | Source | Confidence |
+|-------|--------|------------|
+${routes || "| [NEEDS LLM INPUT] | [NEEDS LLM INPUT] | low |"}
+
+## Conventions
+
+[NEEDS LLM INPUT]
+
+## Scanner Metadata
+
+- Generated At: ${scan.generatedAt}
+- FET Version: ${FET_VERSION}
+- Scanner Version: ${scan.scannerVersion}
+- Warnings: ${scan.warnings.length ? scan.warnings.join("; ") : "none"}
+${AUTO_END}
+
+${USER_BEGIN}
+## Notes For AI
+
+[NEEDS LLM INPUT]
+${USER_END}
+`;
+}
+
+// src/templates/config-yaml.ts
+import { stringify } from "yaml";
+function renderFetConfig(scan) {
+  return stringify({
+    fet: {
+      schemaVersion: 1,
+      generatedAt: scan.generatedAt,
+      fetVersion: FET_VERSION,
+      scannerVersion: scan.scannerVersion,
+      project: {
+        packageManager: scan.project.packageManager,
+        packageManagerConfidence: scan.project.packageManagerConfidence,
+        framework: scan.project.framework,
+        language: scan.project.language,
+        monorepo: scan.project.monorepo,
+        workspaces: scan.project.workspaces
+      },
+      commands: scan.commands,
+      validation: {
+        monorepo: scan.project.monorepo,
+        missing: {
+          lint: "warn",
+          typecheck: "warn",
+          test: "warn"
+        },
+        workspaces: scan.project.workspaces
+      }
+    }
+  });
+}
+
+// src/templates/verify-instructions.ts
+function renderVerifyInstructions(changeId, generatedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  return `---
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generatedAt: ${generatedAt}
+changeId: ${changeId}
+purpose: manual-verify
+---
+
+# Verify Instructions
+
+\u8BF7\u6309\u987A\u5E8F\u5B8C\u6210\u4EE5\u4E0B\u68C0\u67E5\uFF1A
+
+1. \u8FD0\u884C OpenSpec \u89C4\u8303\u6821\u9A8C\uFF1A\`openspec verify\`
+2. \u6309\u9879\u76EE\u7EA6\u5B9A\u8FD0\u884C lint\u3001typecheck\u3001test\u3002
+3. \u68C0\u67E5\u672C\u6B21 change \u7684 \`tasks.md\` \u662F\u5426\u4E0E\u5B9E\u73B0\u72B6\u6001\u4E00\u81F4\u3002
+
+\u5B8C\u6210\u540E\u8FD0\u884C\uFF1A
+
+\`\`\`sh
+fet verify --done --change ${changeId}
+\`\`\`
+`;
+}
+
+// src/templates/gitignore.ts
+var BEGIN = "# FET:BEGIN LOCAL STATE";
+var END = "# FET:END LOCAL STATE";
+var RULES = [
+  "openspec/fet-state.json",
+  "openspec/.fet.lock",
+  "openspec/.fet-init-journal.json",
+  "openspec/changes/*/fet-state.json",
+  "openspec/changes/*/.fet/"
+];
+function mergeGitignore(existing) {
+  const block = `${BEGIN}
+${RULES.join("\n")}
+${END}`;
+  if (!existing || !existing.trim()) {
+    return `${block}
+`;
+  }
+  const start = existing.indexOf(BEGIN);
+  const end = existing.indexOf(END);
+  if (start !== -1 && end !== -1 && end > start) {
+    return `${existing.slice(0, start)}${block}${existing.slice(end + END.length)}`;
+  }
+  return `${existing.replace(/\s*$/, "")}
+
+${block}
+`;
+}
+
+// src/commands/update-context.ts
+import { readFile as readFile4 } from "fs/promises";
+import { join as join5 } from "path";
+
+// src/config/yaml.ts
+import { readFile as readFile3 } from "fs/promises";
+import { parseDocument } from "yaml";
+async function mergeFetConfig(configPath, renderedFetYaml) {
+  const fetDoc = parseDocument(renderedFetYaml);
+  const nextFet = fetDoc.get("fet", true);
+  let existing = "";
+  try {
+    existing = await readFile3(configPath, "utf8");
+  } catch {
+    return renderedFetYaml;
+  }
+  const doc = parseDocument(existing || "{}");
+  doc.set("fet", nextFet);
+  return doc.toString();
+}
+
+// src/commands/update-context.ts
+async function updateContextCommand(ctx) {
+  await withProjectLock(
+    ctx.projectRoot,
+    { command: "update-context", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
+    async () => updateContextFiles(ctx)
+  );
+  ctx.output.result({
+    ok: true,
+    command: "update-context",
+    summary: "\u5DF2\u66F4\u65B0 AGENTS.md \u4E0E openspec/config.yaml \u7684 FET \u6258\u7BA1\u533A\u57DF\u3002"
+  });
+}
+async function updateContextFiles(ctx) {
+  const scan = await ctx.scanner.scan(ctx.projectRoot, {});
+  const agentsPath = join5(ctx.projectRoot, "AGENTS.md");
+  const configPath = join5(ctx.projectRoot, "openspec", "config.yaml");
+  const existingAgents = await readOptional(agentsPath);
+  const warnings = [...scan.warnings];
+  if (existingAgents && hasInvalidManagedAutoRegion(existingAgents)) {
+    throw new FetError({
+      code: "CONFIG_INVALID" /* ConfigInvalid */,
+      message: "AGENTS.md \u7684 FET \u6258\u7BA1\u6807\u8BB0\u635F\u574F\u6216\u91CD\u590D",
+      details: { path: "AGENTS.md" },
+      suggestedCommand: "\u624B\u52A8\u4FEE\u590D FET:BEGIN AUTO / FET:END AUTO \u6807\u8BB0\u540E\u91CD\u8BD5"
+    });
+  }
+  if (existingAgents && !hasManagedAutoRegion(existingAgents)) {
+    if (!ctx.yes) {
+      throw new FetError({
+        code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
+        message: "AGENTS.md \u5DF2\u5B58\u5728\u4E14\u4E0D\u5305\u542B FET \u6258\u7BA1\u533A\u57DF",
+        details: { path: "AGENTS.md" },
+        suggestedCommand: ctx.command === "init" ? "\u786E\u8BA4\u53EF\u5907\u4EFD\u5E76\u66FF\u6362\u540E\u8FD0\u884C fet init --yes" : "\u786E\u8BA4\u53EF\u5907\u4EFD\u5E76\u66FF\u6362\u540E\u8FD0\u884C fet update-context --yes"
+      });
+    }
+    const backupPath = await createBackup(agentsPath);
+    if (backupPath) {
+      warnings.push(`\u5DF2\u5907\u4EFD\u975E\u6258\u7BA1 AGENTS.md \u5230 ${backupPath}`);
+    }
+  }
+  await atomicWrite(agentsPath, replaceManagedRegion(existingAgents, renderAgentsMd(scan)));
+  await atomicWrite(configPath, await mergeFetConfig(configPath, renderFetConfig(scan)));
+  const state = await ctx.stateStore.getOrCreateGlobal();
+  state.context = {
+    agentsMdUpdatedAt: scan.generatedAt,
+    configUpdatedAt: scan.generatedAt,
+    scannerVersion: scan.scannerVersion
+  };
+  await ctx.stateStore.writeGlobal(state);
+  return { warnings };
+}
+async function readOptional(path) {
+  try {
+    return await readFile4(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+
+// src/commands/init.ts
+async function initCommand(ctx) {
+  const alreadyInitialized = await exists(join6(ctx.projectRoot, "openspec", "config.yaml"));
+  await withProjectLock(
+    ctx.projectRoot,
+    { command: "init", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
+    async () => {
+      const journal = createInitJournal(ctx.fetVersion);
+      await writeInitJournal(ctx.projectRoot, journal);
+      const identity = await ctx.openSpec.resolveExecutable();
+      if (!alreadyInitialized) {
+        const result = await ctx.openSpec.run("init", ["--tools", "none"], { cwd: ctx.projectRoot, stdio: "inherit" });
+        if (result.exitCode !== 0) {
+          process.exitCode = result.exitCode;
+          return;
+        }
+      }
+      const contextResult = await updateContextFiles(ctx);
+      await ensureGitignore(ctx);
+      const state = await ctx.stateStore.getOrCreateGlobal();
+      state.openspec = identity;
+      for (const adapter of ctx.toolAdapters) {
+        const plan = await adapter.planInstall(ctx.projectRoot);
+        const result = await adapter.install(ctx.projectRoot, plan, ctx.yes);
+        state.toolAdapters[adapter.tool] = {
+          adapterVersion: adapter.adapterVersion,
+          installed: true,
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        journal.steps.push(...result.written.map((path) => ({ operation: "write", path, status: "done" })));
+      }
+      journal.completedAt = (/* @__PURE__ */ new Date()).toISOString();
+      await writeInitJournal(ctx.projectRoot, journal);
+      await ctx.stateStore.writeGlobal(state);
+      for (const warning of contextResult.warnings) {
+        ctx.output.warn(warning);
+      }
+    }
+  );
+  ctx.output.result({
+    ok: true,
+    command: "init",
+    summary: "FET \u521D\u59CB\u5316\u5B8C\u6210\u3002",
+    nextSteps: ["\u4F7F\u7528 fet propose/new \u521B\u5EFA OpenSpec change", "\u4F7F\u7528 fet doctor \u68C0\u67E5\u9879\u76EE\u72B6\u6001"]
+  });
+}
+async function ensureGitignore(ctx) {
+  const gitignorePath = join6(ctx.projectRoot, ".gitignore");
+  const existing = await readOptional2(gitignorePath);
+  await atomicWrite(gitignorePath, mergeGitignore(existing));
+}
+async function readOptional2(path) {
+  try {
+    return await readFile5(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function exists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/commands/doctor.ts
+import { stat as stat3 } from "fs/promises";
+import { join as join7 } from "path";
+async function doctorCommand(ctx, options = {}) {
+  const checks = [];
+  checks.push(await checkOpenSpec(ctx));
+  checks.push(await checkState(ctx));
+  checks.push(await checkFile("agents", join7(ctx.projectRoot, "AGENTS.md"), "AGENTS.md \u7F3A\u5931", "fet update-context"));
+  checks.push(await checkFile("config", join7(ctx.projectRoot, "openspec", "config.yaml"), "openspec/config.yaml \u7F3A\u5931", "fet init"));
+  for (const adapter of ctx.toolAdapters) {
+    checks.push(...await adapter.doctor(ctx.projectRoot));
+  }
+  const lockPath = join7(ctx.projectRoot, "openspec", ".fet.lock");
+  if (await exists2(lockPath)) {
+    if (options.fixLock) {
+      await clearLock(ctx.projectRoot);
+      checks.push({ id: "lock", status: "pass", message: "\u5DF2\u6E05\u7406 openspec/.fet.lock" });
+    } else {
+      checks.push({ id: "lock", status: "warn", message: "\u5B58\u5728 openspec/.fet.lock", suggestedCommand: "fet doctor --fix-lock" });
+    }
+  }
+  const warnings = checks.filter((check) => check.status !== "pass").map((check) => check.message);
+  ctx.output.result({
+    ok: true,
+    command: "doctor",
+    summary: warnings.length ? `\u8BCA\u65AD\u5B8C\u6210\uFF0C\u53D1\u73B0 ${warnings.length} \u4E2A\u9700\u8981\u5173\u6CE8\u7684\u95EE\u9898\u3002` : "\u8BCA\u65AD\u5B8C\u6210\uFF0C\u672A\u53D1\u73B0\u660E\u663E\u95EE\u9898\u3002",
+    warnings,
+    data: checks
+  });
+}
+async function checkOpenSpec(ctx) {
+  try {
+    const identity = await ctx.openSpec.resolveExecutable();
+    return { id: "openspec", status: "pass", message: `OpenSpec: ${identity.executablePath} (${identity.version})` };
+  } catch (error) {
+    return { id: "openspec", status: "fail", message: error instanceof Error ? error.message : "OpenSpec \u68C0\u6D4B\u5931\u8D25" };
+  }
+}
+async function checkState(ctx) {
+  try {
+    const state = await ctx.stateStore.readGlobal();
+    return state ? { id: "state", status: "pass", message: "FET \u5168\u5C40\u72B6\u6001\u53EF\u8BFB\u53D6" } : { id: "state", status: "warn", message: "FET \u5168\u5C40\u72B6\u6001\u5C1A\u672A\u521D\u59CB\u5316", suggestedCommand: "fet init" };
+  } catch (error) {
+    return { id: "state", status: "fail", message: error instanceof Error ? error.message : "FET \u72B6\u6001\u8BFB\u53D6\u5931\u8D25" };
+  }
+}
+async function checkFile(id, path, missing, suggestedCommand) {
+  return await exists2(path) ? { id, status: "pass", message: `${id} \u5B58\u5728` } : { id, status: "warn", message: missing, suggestedCommand };
+}
+async function exists2(path) {
+  try {
+    await stat3(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/state/project.ts
+import { execFile } from "child_process";
+import { promisify } from "util";
+var execFileAsync = promisify(execFile);
+async function detectProjectIdentity(projectRoot) {
+  const [gitRoot, branch, headCommit] = await Promise.all([
+    git(projectRoot, ["rev-parse", "--show-toplevel"]),
+    git(projectRoot, ["branch", "--show-current"]),
+    git(projectRoot, ["rev-parse", "HEAD"])
+  ]);
+  return {
+    gitRoot,
+    worktreePath: projectRoot,
+    branch,
+    headCommit
+  };
+}
+async function git(cwd, args) {
+  try {
+    const { stdout } = await execFileAsync("git", args, { cwd });
+    return stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+
+// src/state/store.ts
+import { mkdir as mkdir3, readFile as readFile6 } from "fs/promises";
+import { join as join8 } from "path";
+
+// src/state/schema.ts
+var phases = ["explore", "propose", "implement", "verify", "sync", "archive"];
+function createGlobalState(fetVersion, project) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: 1,
+    fetVersion,
+    createdAt: now,
+    updatedAt: now,
+    project,
+    openspec: null,
+    activeChangeId: null,
+    openChangeIds: [],
+    context: {
+      agentsMdUpdatedAt: null,
+      configUpdatedAt: null,
+      scannerVersion: 1
+    },
+    toolAdapters: {},
+    verifyAuthorization: null,
+    lastDoctor: null
+  };
+}
+function createChangeState(fetVersion, changeId, phase) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    schemaVersion: 1,
+    fetVersion,
+    changeId,
+    createdAt: now,
+    updatedAt: now,
+    currentPhase: phase,
+    phases: Object.fromEntries(
+      phases.map((item) => [item, { status: item === phase ? "in_progress" : "not_started" }])
+    ),
+    tasks: {
+      source: "tasks.md",
+      completedIds: [],
+      lastSyncedAt: null
+    },
+    manualVerify: null,
+    lastOpenSpecCommand: null,
+    warnings: []
+  };
+}
+function assertGlobalState(value) {
+  if (!isRecord(value) || value.schemaVersion !== 1) {
+    throw unsupportedSchema("\u5168\u5C40\u72B6\u6001 schema \u4E0D\u53D7\u652F\u6301");
+  }
+  if (typeof value.fetVersion !== "string" || !isRecord(value.project)) {
+    throw corruptedState("\u5168\u5C40\u72B6\u6001\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5");
+  }
+}
+function assertChangeState(value) {
+  if (!isRecord(value) || value.schemaVersion !== 1) {
+    throw unsupportedSchema("\u53D8\u66F4\u72B6\u6001 schema \u4E0D\u53D7\u652F\u6301");
+  }
+  if (typeof value.fetVersion !== "string" || typeof value.changeId !== "string") {
+    throw corruptedState("\u53D8\u66F4\u72B6\u6001\u7F3A\u5C11\u5FC5\u586B\u5B57\u6BB5");
+  }
+}
+function unsupportedSchema(message) {
+  return new FetError({
+    code: "STATE_SCHEMA_UNSUPPORTED" /* StateSchemaUnsupported */,
+    message,
+    suggestedCommand: "npm update -g @nick848/fet"
+  });
+}
+function corruptedState(message) {
+  return new FetError({
+    code: "STATE_CORRUPTED" /* StateCorrupted */,
+    message,
+    suggestedCommand: "fet doctor --fix"
+  });
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+
+// src/state/store.ts
+var StateStore = class {
+  constructor(projectRoot, fetVersion, project) {
+    this.projectRoot = projectRoot;
+    this.fetVersion = fetVersion;
+    this.project = project;
+  }
+  projectRoot;
+  fetVersion;
+  project;
+  async readGlobal() {
+    try {
+      const value = JSON.parse(await readFile6(this.globalPath(), "utf8"));
+      assertGlobalState(value);
+      return value;
+    } catch (error) {
+      if (isNotFound(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getOrCreateGlobal() {
+    return await this.readGlobal() ?? createGlobalState(this.fetVersion, this.project);
+  }
+  async writeGlobal(state) {
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await mkdir3(join8(this.projectRoot, "openspec"), { recursive: true });
+    await atomicWrite(this.globalPath(), `${JSON.stringify(state, null, 2)}
+`);
+  }
+  async readChange(changeId) {
+    try {
+      const value = JSON.parse(await readFile6(this.changePath(changeId), "utf8"));
+      assertChangeState(value);
+      return value;
+    } catch (error) {
+      if (isNotFound(error)) {
+        return null;
+      }
+      throw error;
+    }
+  }
+  async getOrCreateChange(changeId, phase) {
+    return await this.readChange(changeId) ?? createChangeState(this.fetVersion, changeId, phase);
+  }
+  async writeChange(state) {
+    state.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    await mkdir3(join8(this.projectRoot, "openspec", "changes", state.changeId), { recursive: true });
+    await atomicWrite(this.changePath(state.changeId), `${JSON.stringify(state, null, 2)}
+`);
+  }
+  globalPath() {
+    return join8(this.projectRoot, "openspec", "fet-state.json");
+  }
+  changePath(changeId) {
+    return join8(this.projectRoot, "openspec", "changes", changeId, "fet-state.json");
+  }
+};
+function isNotFound(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+
+// src/state/tasks.ts
+import { readFile as readFile7 } from "fs/promises";
+async function readCompletedTaskIds(tasksPath) {
+  let content;
+  try {
+    content = await readFile7(tasksPath, "utf8");
+  } catch {
+    return [];
+  }
+  const completed = [];
+  const pattern = /^\s*[-*]\s+\[[xX]\]\s+([0-9]+(?:\.[0-9]+)*)/gm;
+  let match;
+  while (match = pattern.exec(content)) {
+    if (match[1]) {
+      completed.push(match[1]);
+    }
+  }
+  return completed;
+}
+
+// src/commands/proxy.ts
+var phaseByCommand = {
+  explore: "explore",
+  propose: "propose",
+  new: "propose",
+  continue: "propose",
+  ff: "propose",
+  apply: "implement",
+  verify: "verify",
+  sync: "sync",
+  archive: "archive",
+  "bulk-archive": "archive",
+  onboard: "explore"
+};
+async function proxyCommand(ctx, command, args) {
+  const openSpecArgs = stripFetOptions(args);
+  await withProjectLock(
+    ctx.projectRoot,
+    { command, cwd: ctx.cwd, fetVersion: ctx.fetVersion },
+    async () => {
+      if (["sync", "archive", "bulk-archive"].includes(command)) {
+        await assertVerified(ctx);
+      }
+      const mapped = await mapOpenSpecCommand(ctx, command, openSpecArgs);
+      const result = await ctx.openSpec.run(mapped.command, mapped.args, { cwd: ctx.projectRoot, stdio: ctx.json ? "pipe" : "inherit" });
+      if (result.exitCode !== 0) {
+        throw new FetError({
+          code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+          message: `OpenSpec ${command} \u6267\u884C\u5931\u8D25`,
+          details: result,
+          recoverable: true
+        });
+      }
+      const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
+      const state = await ctx.stateStore.getOrCreateGlobal();
+      state.openChangeIds = inspection.changes;
+      if (ctx.changeId && inspection.changes.includes(ctx.changeId)) {
+        state.activeChangeId = ctx.changeId;
+      } else if (state.activeChangeId && !inspection.changes.includes(state.activeChangeId)) {
+        state.activeChangeId = inspection.changes.length === 1 ? inspection.changes[0] ?? null : null;
+      } else if (!state.activeChangeId && inspection.changes.length === 1) {
+        state.activeChangeId = inspection.changes[0] ?? null;
+      }
+      await ctx.stateStore.writeGlobal(state);
+      const changeId = ctx.changeId ?? state.activeChangeId;
+      if (changeId && inspection.changes.includes(changeId)) {
+        const changeInspection = await ctx.openSpec.inspectChange(ctx.projectRoot, changeId);
+        const changeState = await ctx.stateStore.getOrCreateChange(changeId, phaseByCommand[command] ?? "propose");
+        changeState.currentPhase = phaseByCommand[command] ?? changeState.currentPhase;
+        changeState.phases[changeState.currentPhase] = {
+          status: "done",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        changeState.lastOpenSpecCommand = {
+          command: mapped.command,
+          args: mapped.args,
+          exitCode: result.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);
+      }
+    }
+  );
+  ctx.output.result({
+    ok: true,
+    command,
+    summary: `fet ${command} \u5B8C\u6210\u3002`
+  });
+}
+async function passthroughCommand(ctx, command, args) {
+  const result = await ctx.openSpec.run(command, stripFetOptions(args), { cwd: ctx.projectRoot, stdio: ctx.json ? "pipe" : "inherit" });
+  if (result.exitCode !== 0) {
+    throw new FetError({
+      code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+      message: `OpenSpec ${command} \u6267\u884C\u5931\u8D25`,
+      details: result
+    });
+  }
+}
+function stripFetOptions(args) {
+  const result = [];
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--cwd" || arg === "--change") {
+      index += 1;
+      continue;
+    }
+    if (arg?.startsWith("--cwd=") || arg?.startsWith("--change=")) {
+      continue;
+    }
+    if (arg === "--yes" || arg === "--json" || arg === "--verbose" || arg === "--no-color") {
+      continue;
+    }
+    if (arg) {
+      result.push(arg);
+    }
+  }
+  return result;
+}
+async function mapOpenSpecCommand(ctx, command, args) {
+  switch (command) {
+    case "propose":
+    case "new":
+      return { command: "new", args: args[0] === "change" ? args : ["change", ...args] };
+    case "continue":
+      return { command: "instructions", args: [...withoutUndefined(args[0] ? [args[0]] : ["proposal"]), "--change", await requireChangeId(ctx)] };
+    case "ff":
+      return { command: "status", args: ["--change", await requireChangeId(ctx)] };
+    case "apply":
+      return { command: "instructions", args: ["apply", "--change", await requireChangeId(ctx)] };
+    case "sync":
+      return { command: "validate", args: [ctx.changeId ?? args[0] ?? await requireChangeId(ctx), "--type", "change", "--strict"] };
+    case "archive":
+      return { command: "archive", args: [ctx.changeId ?? args[0] ?? await requireChangeId(ctx), ...args.slice(ctx.changeId ? 0 : 1)] };
+    case "bulk-archive":
+      throw new FetError({
+        code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+        message: "OpenSpec 1.2.0 \u4E0D\u63D0\u4F9B bulk-archive \u9876\u5C42\u547D\u4EE4",
+        suggestedCommand: "\u9010\u4E2A\u6267\u884C fet archive --change <change-id>"
+      });
+    case "explore":
+      return { command: "instructions", args: ["proposal", "--change", await requireChangeId(ctx)] };
+    case "onboard":
+      return { command: "instructions", args: [] };
+    default:
+      return { command, args };
+  }
+}
+async function requireChangeId(ctx) {
+  if (ctx.changeId) {
+    return ctx.changeId;
+  }
+  const state = await ctx.stateStore.getOrCreateGlobal();
+  if (state.activeChangeId) {
+    return state.activeChangeId;
+  }
+  const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
+  if (inspection.changes.length === 1 && inspection.changes[0]) {
+    return inspection.changes[0];
+  }
+  throw new FetError({
+    code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+    message: "\u8BE5\u547D\u4EE4\u9700\u8981\u660E\u786E\u7684 change",
+    details: { openChangeIds: inspection.changes },
+    suggestedCommand: "\u6DFB\u52A0 --change <change-id>"
+  });
+}
+function withoutUndefined(values) {
+  return values.filter(Boolean);
+}
+async function assertVerified(ctx) {
+  const global = await ctx.stateStore.getOrCreateGlobal();
+  const changeId = ctx.changeId ?? global.activeChangeId;
+  if (!changeId) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: "\u672A\u6307\u5B9A change\uFF0C\u65E0\u6CD5\u68C0\u67E5 verify \u72B6\u6001",
+      suggestedCommand: "fet verify --done --change <change-id>"
+    });
+  }
+  const change = await ctx.stateStore.readChange(changeId);
+  const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
+  if (!inspection.changes.includes(changeId)) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: "\u6307\u5B9A\u7684 change \u4E0D\u5B58\u5728\u6216\u5DF2\u5F52\u6863",
+      details: { changeId, openChangeIds: inspection.changes },
+      suggestedCommand: "fet doctor"
+    });
+  }
+  if (change?.manualVerify?.status !== "declared_done") {
+    throw new FetError({
+      code: "STATE_CORRUPTED" /* StateCorrupted */,
+      message: "\u5F53\u524D change \u5C1A\u672A\u901A\u8FC7 FET verify",
+      details: { changeId },
+      suggestedCommand: `fet verify --change ${changeId}`
+    });
+  }
+}
+
+// src/commands/verify.ts
+import { createHash } from "crypto";
+import { mkdir as mkdir4, readFile as readFile8, stat as stat4 } from "fs/promises";
+import { join as join9 } from "path";
+async function verifyCommand(ctx, options) {
+  if (options.auto) {
+    const scan = await ctx.scanner.scan(ctx.projectRoot, {});
+    const plan = {
+      schemaVersion: 1,
+      packageManager: scan.project.packageManager,
+      workspaces: [
+        {
+          name: "root",
+          cwd: ".",
+          commands: Object.entries(scan.commands).filter(([name]) => ["lint", "typecheck", "test"].includes(name)).map(([dimension, command]) => ({
+            dimension,
+            command: command.command,
+            source: command.source,
+            required: command.required,
+            statusIfMissing: command.required ? "fail" : "warn"
+          }))
+        }
+      ],
+      missing: ["lint", "typecheck", "test"].filter((name) => !scan.commands[name])
+    };
+    if (ctx.yes) {
+      const global = await ctx.stateStore.getOrCreateGlobal();
+      global.verifyAuthorization = {
+        schemaVersion: 1,
+        approvedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        commandFingerprint: fingerprint(plan),
+        packageManager: plan.packageManager,
+        plan: plan.workspaces.flatMap(
+          (workspace) => workspace.commands.map((command) => ({
+            cwd: workspace.cwd,
+            dimension: command.dimension,
+            command: command.command,
+            source: command.source,
+            required: command.required
+          }))
+        )
+      };
+      await ctx.stateStore.writeGlobal(global);
+    }
+    ctx.output.result({
+      ok: true,
+      command: "verify",
+      summary: ctx.yes ? "\u5DF2\u786E\u8BA4 verify --auto \u6267\u884C\u8BA1\u5212\uFF1BMVP \u6682\u4E0D\u6267\u884C\u4ED3\u5E93\u811A\u672C\u3002" : "\u5DF2\u751F\u6210 verify --auto \u6267\u884C\u8BA1\u5212\uFF1BMVP \u6682\u4E0D\u6267\u884C\u4ED3\u5E93\u811A\u672C\u3002",
+      warnings: plan.missing.map((name) => `\u672A\u53D1\u73B0 ${name} \u811A\u672C\uFF0C\u5C06\u5728\u81EA\u52A8\u6267\u884C\u7248\u672C\u4E2D\u6309\u914D\u7F6E\u5904\u7406\u3002`),
+      data: plan,
+      nextSteps: ctx.yes ? ["\u5F53\u524D\u7248\u672C\u8BF7\u8FD0\u884C fet verify \u8FDB\u5165\u624B\u52A8\u9A8C\u8BC1\u6A21\u5F0F"] : ["\u5BA1\u6838\u6267\u884C\u8BA1\u5212", "\u786E\u8BA4\u8BA1\u5212\u540E\u53EF\u8FD0\u884C fet verify --auto --yes", "\u5F53\u524D\u7248\u672C\u8BF7\u8FD0\u884C fet verify \u8FDB\u5165\u624B\u52A8\u9A8C\u8BC1\u6A21\u5F0F"]
+    });
+    return;
+  }
+  await withProjectLock(
+    ctx.projectRoot,
+    { command: "verify", cwd: ctx.cwd, fetVersion: ctx.fetVersion },
+    async () => {
+      const changeId = await resolveChangeId(ctx);
+      if (options.done) {
+        await markDone(ctx, changeId);
+      } else {
+        await writeInstructions(ctx, changeId);
+      }
+    }
+  );
+}
+async function writeInstructions(ctx, changeId) {
+  await assertChangeExists(ctx, changeId);
+  const generatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  const dir = join9(ctx.projectRoot, "openspec", "changes", changeId, ".fet");
+  const instructionsPath = join9(dir, "verify-instructions.md");
+  await mkdir4(dir, { recursive: true });
+  await atomicWrite(instructionsPath, renderVerifyInstructions(changeId, generatedAt));
+  const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
+  state.currentPhase = "verify";
+  state.phases.verify = { status: "in_progress", updatedAt: generatedAt };
+  await ctx.stateStore.writeChange(state);
+  ctx.output.result({
+    ok: true,
+    command: "verify",
+    summary: "\u5DF2\u751F\u6210\u624B\u52A8\u9A8C\u8BC1\u6307\u4EE4\u3002",
+    nextSteps: [`\u9605\u8BFB openspec/changes/${changeId}/.fet/verify-instructions.md`, `\u5B8C\u6210\u540E\u8FD0\u884C fet verify --done --change ${changeId}`]
+  });
+}
+async function markDone(ctx, changeId) {
+  await assertChangeExists(ctx, changeId);
+  const declaredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const instructionsPath = join9(ctx.projectRoot, "openspec", "changes", changeId, ".fet", "verify-instructions.md");
+  const instructions = await readInstructions(instructionsPath, changeId);
+  const instructionsGeneratedAt = readFrontMatterValue(instructions, "generatedAt") ?? declaredAt;
+  const state = await ctx.stateStore.getOrCreateChange(changeId, "verify");
+  state.currentPhase = "verify";
+  state.phases.verify = { status: "done", updatedAt: declaredAt };
+  state.manualVerify = {
+    mode: "manual",
+    status: "declared_done",
+    declaredAt,
+    instructionsPath: `openspec/changes/${changeId}/.fet/verify-instructions.md`,
+    instructionsGeneratedAt,
+    evidence: null
+  };
+  await ctx.stateStore.writeChange(state);
+  ctx.output.result({
+    ok: true,
+    command: "verify",
+    summary: "\u5DF2\u8BB0\u5F55\u624B\u52A8\u9A8C\u8BC1\u5B8C\u6210\u58F0\u660E\u3002",
+    nextSteps: [`fet sync --change ${changeId}`, `fet archive --change ${changeId}`]
+  });
+}
+async function assertChangeExists(ctx, changeId) {
+  const inspection = await ctx.openSpec.inspectChange(ctx.projectRoot, changeId);
+  if (!inspection.exists) {
+    throw new FetError({
+      code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+      message: "\u6307\u5B9A\u7684 change \u4E0D\u5B58\u5728",
+      details: { changeId },
+      suggestedCommand: "fet verify --change <change-id>"
+    });
+  }
+}
+async function readInstructions(path, changeId) {
+  try {
+    await stat4(path);
+    const content = await readFile8(path, "utf8");
+    const fileChangeId = readFrontMatterValue(content, "changeId");
+    if (fileChangeId !== changeId) {
+      throw new FetError({
+        code: "STATE_CORRUPTED" /* StateCorrupted */,
+        message: "\u9A8C\u8BC1\u6307\u4EE4\u6587\u4EF6\u4E0E\u5F53\u524D change \u4E0D\u5339\u914D",
+        details: { expected: changeId, actual: fileChangeId },
+        suggestedCommand: `fet verify --change ${changeId}`
+      });
+    }
+    return content;
+  } catch (error) {
+    if (error instanceof FetError) {
+      throw error;
+    }
+    throw new FetError({
+      code: "STATE_CORRUPTED" /* StateCorrupted */,
+      message: "\u9A8C\u8BC1\u6307\u4EE4\u6587\u4EF6\u4E0D\u5B58\u5728\u6216\u65E0\u6CD5\u8BFB\u53D6",
+      details: { path },
+      suggestedCommand: `fet verify --change ${changeId}`
+    });
+  }
+}
+function readFrontMatterValue(content, key) {
+  const match = content.match(new RegExp(`^${key}:\\s*(.+)$`, "m"));
+  return match?.[1]?.trim() ?? null;
+}
+function fingerprint(value) {
+  return `sha256:${createHash("sha256").update(JSON.stringify(value)).digest("hex")}`;
+}
+async function resolveChangeId(ctx) {
+  if (ctx.changeId) {
+    return ctx.changeId;
+  }
+  const global = await ctx.stateStore.getOrCreateGlobal();
+  if (global.activeChangeId) {
+    return global.activeChangeId;
+  }
+  const inspection = await ctx.openSpec.inspectProject(ctx.projectRoot);
+  if (inspection.changes.length === 1 && inspection.changes[0]) {
+    return inspection.changes[0];
+  }
+  throw new FetError({
+    code: "INVALID_ARGUMENTS" /* InvalidArguments */,
+    message: "\u65E0\u6CD5\u786E\u5B9A\u8981\u9A8C\u8BC1\u7684 change",
+    details: { openChangeIds: inspection.changes },
+    suggestedCommand: "fet verify --change <change-id>"
+  });
+}
+
+// src/cli/context.ts
+import { resolve } from "path";
+
+// src/adapters/cursor/index.ts
+import { mkdir as mkdir5, readFile as readFile9, stat as stat5 } from "fs/promises";
+import { dirname as dirname5, join as join10 } from "path";
+
+// src/adapters/cursor/templates.ts
+var commands = [
+  "explore",
+  "propose",
+  "new",
+  "continue",
+  "ff",
+  "apply",
+  "verify",
+  "sync",
+  "archive",
+  "bulk-archive",
+  "onboard"
+];
+function cursorSkillFiles() {
+  return commands.map((command) => ({
+    path: `.cursor/skills/fet-${command}/SKILL.md`,
+    content: renderSkill(command)
+  }));
+}
+function cursorRuleFile() {
+  return {
+    path: ".cursor/rules/fet-context.mdc",
+    content: `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: cursor-adapter
+adapterVersion: 1
+FET:END -->
+
+---
+description: Load FET project context for implementation tasks
+alwaysApply: false
+---
+
+\u5F53\u7528\u6237\u8BF7\u6C42\u4FEE\u6539\u9879\u76EE\u3001\u5B9E\u73B0 OpenSpec change\u3001\u8FD0\u884C FET \u5DE5\u4F5C\u6D41\u6216\u89E3\u91CA\u9879\u76EE\u7ED3\u6784\u65F6\uFF0C\u4F18\u5148\u9605\u8BFB\uFF1A
+
+- AGENTS.md
+- openspec/config.yaml
+- \u5F53\u524D change \u76EE\u5F55\u4E0B\u7684 OpenSpec \u89C4\u5212\u4EA7\u7269
+
+\u5982\u679C\u7528\u6237\u8F93\u5165\u7C7B\u4F3C \`/fet apply\` \u7684\u8BF7\u6C42\uFF0CCursor \u5F53\u524D\u7248\u672C\u672A\u5FC5\u4F1A\u628A\u672C\u6587\u4EF6\u6CE8\u518C\u4E3A\u539F\u751F slash command\u3002\u6B64\u65F6\u8BF7\u628A\u5B83\u5F53\u4F5C\u5DE5\u4F5C\u6D41\u610F\u56FE\uFF0C\u5E76\u63D0\u793A\u7528\u6237\u5728\u7EC8\u7AEF\u6267\u884C\u5BF9\u5E94\u7684 \`fet <cmd>\` \u547D\u4EE4\u3002
+`
+  };
+}
+function renderSkill(command) {
+  return `<!-- FET:MANAGED
+schemaVersion: 1
+fetVersion: ${FET_VERSION}
+generator: cursor-adapter
+adapterVersion: 1
+command: fet ${command}
+FET:END -->
+
+---
+name: fet-${command}
+description: Run FET-managed OpenSpec ${command} workflow from the terminal
+disable-model-invocation: true
+---
+
+\u6CE8\u610F\uFF1A\u6B64\u6587\u4EF6\u91C7\u7528 Cursor Skill \u76EE\u5F55\u7ED3\u6784\u3002\u5B83\u63D0\u4F9B \`/fet-${command}\` \u98CE\u683C\u7684\u5DE5\u4F5C\u6D41\u8BF4\u660E\uFF0C\u4E0D\u627F\u8BFA\u6CE8\u518C \`/fet ${command}\` \u8FD9\u79CD\u5E26\u7A7A\u683C\u7684\u539F\u751F slash command\u3002
+
+\u8BF7\u5728\u7EC8\u7AEF\u4E2D\u6267\u884C\uFF1A
+
+\`\`\`sh
+fet ${command}
+\`\`\`
+
+\u6267\u884C\u524D\u8BF7\u786E\u8BA4\u5DF2\u9605\u8BFB AGENTS.md \u4E0E openspec/config.yaml\u3002
+`;
+}
+
+// src/adapters/cursor/index.ts
+var CursorAdapter = class {
+  tool = "cursor";
+  adapterVersion = 1;
+  async detect(projectRoot) {
+    return {
+      detected: await exists3(join10(projectRoot, ".cursor")),
+      reason: "Cursor adapter is available for any project"
+    };
+  }
+  async planInstall(_projectRoot) {
+    return {
+      tool: this.tool,
+      files: [...cursorSkillFiles(), cursorRuleFile()].map((file) => ({
+        ...file,
+        managed: true
+      }))
+    };
+  }
+  async install(projectRoot, plan, force = false) {
+    const written = [];
+    const skipped = [];
+    for (const file of plan.files) {
+      const target = join10(projectRoot, file.path);
+      const existing = await readExisting(target);
+      if (existing && !existing.includes("FET:MANAGED") && !force) {
+        throw new FetError({
+          code: "TOOL_ADAPTER_CONFLICT" /* ToolAdapterConflict */,
+          message: "Cursor \u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728\u4E14\u4E0D\u5F52 FET \u7BA1\u7406",
+          details: { path: file.path },
+          suggestedCommand: "fet init --yes"
+        });
+      }
+      if (existing && !existing.includes("FET:MANAGED") && force) {
+        await createBackup(target);
+      }
+      await mkdir5(dirname5(target), { recursive: true });
+      await atomicWrite(target, file.content);
+      written.push(file.path);
+    }
+    return { tool: this.tool, written, skipped };
+  }
+  async doctor(projectRoot) {
+    const plan = await this.planInstall(projectRoot);
+    const checks = [];
+    for (const file of plan.files) {
+      const target = join10(projectRoot, file.path);
+      const content = await readExisting(target);
+      const managed = Boolean(content?.includes("FET:MANAGED"));
+      const versionMatches = Boolean(content?.includes(`adapterVersion: ${this.adapterVersion}`));
+      checks.push({
+        id: `cursor:${file.path}`,
+        status: !content ? "warn" : managed && versionMatches ? "pass" : "warn",
+        message: !content ? `${file.path} \u7F3A\u5931` : !managed ? `${file.path} \u5B58\u5728\u4F46\u4E0D\u5F52 FET \u7BA1\u7406` : !versionMatches ? `${file.path} adapterVersion \u5DF2\u8FC7\u671F` : `${file.path} \u5B58\u5728\u4E14\u7248\u672C\u5339\u914D`,
+        suggestedCommand: !content || !managed || !versionMatches ? "fet init" : void 0
+      });
+    }
+    return checks;
+  }
+};
+async function readExisting(path) {
+  try {
+    return await readFile9(path, "utf8");
+  } catch {
+    return null;
+  }
+}
+async function exists3(path) {
+  try {
+    await stat5(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/openspec/adapter.ts
+import { execFile as execFile3 } from "child_process";
+import { promisify as promisify3 } from "util";
+
+// src/openspec/inspector.ts
+import { readdir, stat as stat6 } from "fs/promises";
+import { join as join11 } from "path";
+async function inspectOpenSpecProject(projectRoot) {
+  const openspecPath = join11(projectRoot, "openspec");
+  const changesPath = join11(openspecPath, "changes");
+  const archivePath = join11(openspecPath, "archive");
+  return {
+    exists: await exists4(openspecPath),
+    changes: await listDirectories(changesPath),
+    archived: await listDirectories(archivePath)
+  };
+}
+async function inspectOpenSpecChange(projectRoot, changeId) {
+  const changePath = join11(projectRoot, "openspec", "changes", changeId);
+  const tasksPath = join11(changePath, "tasks.md");
+  const specsPath = join11(changePath, "specs");
+  return {
+    changeId,
+    exists: await exists4(changePath),
+    hasProposal: await exists4(join11(changePath, "proposal.md")),
+    hasTasks: await exists4(tasksPath),
+    hasSpecs: await exists4(specsPath),
+    tasksPath,
+    changePath
+  };
+}
+async function listDirectories(path) {
+  try {
+    const entries = await readdir(path, { withFileTypes: true });
+    return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+  } catch {
+    return [];
+  }
+}
+async function exists4(path) {
+  try {
+    await stat6(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/openspec/resolver.ts
+import { execFile as execFile2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execFileAsync2 = promisify2(execFile2);
+async function resolveOpenSpecExecutable() {
+  const executablePath = await findExecutable();
+  const version = await readVersion(executablePath);
+  return {
+    executablePath,
+    version,
+    adapterVersion: 1
+  };
+}
+async function findExecutable() {
+  const command = process.platform === "win32" ? "where.exe" : "which";
+  try {
+    const { stdout } = await exec(command, ["openspec"]);
+    const first = stdout.split(/\r?\n/).map((line) => line.trim()).find(Boolean);
+    if (first) {
+      return first;
+    }
+  } catch {
+  }
+  try {
+    await exec("npx", ["openspec", "--version"]);
+    return "npx openspec";
+  } catch {
+    throw new FetError({
+      code: "OPENSPEC_NOT_FOUND" /* OpenSpecNotFound */,
+      message: "OpenSpec CLI \u672A\u5B89\u88C5",
+      suggestedCommand: "npm install -g @fission-ai/openspec"
+    });
+  }
+}
+async function readVersion(executablePath) {
+  const command = executablePath === "npx openspec" ? "npx" : executablePath;
+  const args = executablePath === "npx openspec" ? ["openspec", "--version"] : ["--version"];
+  try {
+    const { stdout, stderr } = await exec(command, args);
+    return stdout.trim() || stderr.trim() || "unknown";
+  } catch (error) {
+    throw new FetError({
+      code: "OPENSPEC_UNSUPPORTED_VERSION" /* OpenSpecUnsupportedVersion */,
+      message: "\u65E0\u6CD5\u8BFB\u53D6 OpenSpec \u7248\u672C",
+      details: { executablePath },
+      cause: error
+    });
+  }
+}
+function exec(command, args) {
+  return execFileAsync2(command, args, { shell: process.platform === "win32" });
+}
+
+// src/openspec/runner.ts
+import { spawn } from "child_process";
+async function runOpenSpec(executablePath, command, args, options) {
+  const spawnCommand = executablePath === "npx openspec" ? "npx" : executablePath;
+  const spawnArgs = executablePath === "npx openspec" ? ["openspec", command, ...args] : [command, ...args];
+  return new Promise((resolve2, reject) => {
+    const stdout = [];
+    const stderr = [];
+    const child = spawn(spawnCommand, spawnArgs, {
+      cwd: options.cwd,
+      stdio: options.stdio ?? "inherit",
+      shell: process.platform === "win32"
+    });
+    if (child.stdout) {
+      child.stdout.on("data", (chunk) => stdout.push(chunk));
+    }
+    if (child.stderr) {
+      child.stderr.on("data", (chunk) => stderr.push(chunk));
+    }
+    child.on("error", (error) => {
+      reject(
+        new FetError({
+          code: "OPENSPEC_COMMAND_FAILED" /* OpenSpecCommandFailed */,
+          message: "OpenSpec \u547D\u4EE4\u542F\u52A8\u5931\u8D25",
+          details: { command, args },
+          cause: error
+        })
+      );
+    });
+    child.on("close", (exitCode, signal) => {
+      resolve2({
+        command,
+        args,
+        exitCode: exitCode ?? 1,
+        signal,
+        stdout: stdout.length ? Buffer.concat(stdout).toString("utf8") : void 0,
+        stderr: stderr.length ? Buffer.concat(stderr).toString("utf8") : void 0
+      });
+    });
+  });
+}
+
+// src/openspec/adapter.ts
+var execFileAsync3 = promisify3(execFile3);
+var DefaultOpenSpecAdapter = class {
+  identity;
+  async resolveExecutable() {
+    this.identity ??= await resolveOpenSpecExecutable();
+    return this.identity;
+  }
+  async getCapabilities() {
+    const identity = await this.resolveExecutable();
+    const executable = identity.executablePath === "npx openspec" ? "npx" : identity.executablePath;
+    const args = identity.executablePath === "npx openspec" ? ["openspec", "--help"] : ["--help"];
+    try {
+      const { stdout } = await execFileAsync3(executable, args, { shell: process.platform === "win32" });
+      return {
+        version: identity.version,
+        commands: parseCommands(stdout),
+        supported: true
+      };
+    } catch {
+      return {
+        version: identity.version,
+        commands: [],
+        supported: false
+      };
+    }
+  }
+  async run(command, args, options) {
+    const identity = await this.resolveExecutable();
+    return runOpenSpec(identity.executablePath, command, args, options);
+  }
+  inspectProject(projectRoot) {
+    return inspectOpenSpecProject(projectRoot);
+  }
+  inspectChange(projectRoot, changeId) {
+    return inspectOpenSpecChange(projectRoot, changeId);
+  }
+};
+function parseCommands(help) {
+  const known = [
+    "init",
+    "explore",
+    "propose",
+    "new",
+    "continue",
+    "ff",
+    "apply",
+    "verify",
+    "sync",
+    "archive",
+    "bulk-archive",
+    "onboard"
+  ];
+  return known.filter((command) => help.includes(command));
+}
+
+// src/scanner/package.ts
+import { readFile as readFile10, stat as stat7 } from "fs/promises";
+import { join as join12 } from "path";
+import { parse as parse2 } from "yaml";
+async function readPackageJson(projectRoot) {
+  try {
+    return JSON.parse(await readFile10(join12(projectRoot, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+}
+async function detectPackageManager(projectRoot, pkg) {
+  const warnings = [];
+  if (pkg?.packageManager) {
+    const declared = pkg.packageManager.split("@")[0] ?? "unknown";
+    const locks2 = await detectLockManagers(projectRoot);
+    const conflicting = locks2.filter((item) => item !== declared);
+    if (conflicting.length) {
+      warnings.push(`packageManager \u58F0\u660E\u4E3A ${declared}\uFF0C\u4F46\u540C\u65F6\u53D1\u73B0\u9501\u6587\u4EF6\uFF1A${conflicting.join(", ")}`);
+    }
+    return { manager: declared, confidence: "high", warnings };
+  }
+  const locks = await detectLockManagers(projectRoot);
+  if (locks.length > 1) {
+    warnings.push(`\u53D1\u73B0\u591A\u4E2A\u5305\u7BA1\u7406\u5668\u9501\u6587\u4EF6\uFF1A${locks.join(", ")}\uFF0C\u9ED8\u8BA4\u4F7F\u7528 ${locks[0]}`);
+    return { manager: locks[0] ?? "npm", confidence: "medium", warnings };
+  }
+  if (locks[0]) {
+    return { manager: locks[0], confidence: "high", warnings };
+  }
+  return { manager: "npm", confidence: "low", warnings };
+}
+function extractCommands(pkg, packageManager) {
+  const scripts = pkg?.scripts ?? {};
+  const result = {};
+  const scriptNames = ["dev", "build", "lint", "typecheck", "check", "test", "test:unit"];
+  for (const name of scriptNames) {
+    if (scripts[name]) {
+      const dimension = name === "check" ? "typecheck" : name === "test:unit" ? "test" : name;
+      if (result[dimension]) {
+        continue;
+      }
+      result[dimension] = {
+        command: scriptCommand(packageManager, name),
+        source: `package.json:scripts.${name}`,
+        required: name === "build"
+      };
+    }
+  }
+  return result;
+}
+function detectFramework(pkg) {
+  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  const candidates = [
+    ["next", ["next"]],
+    ["nuxt", ["nuxt"]],
+    ["vite", ["vite"]],
+    ["sveltekit", ["@sveltejs/kit"]],
+    ["angular", ["@angular/core", "@angular/cli"]],
+    ["react", ["react"]],
+    ["vue", ["vue"]],
+    ["svelte", ["svelte"]]
+  ];
+  for (const [candidate, packages] of candidates) {
+    if (packages.some((name) => deps[name])) {
+      return { name: candidate, confidence: "high", sources: ["package.json"] };
+    }
+  }
+  return { name: "unknown", confidence: "low", sources: [] };
+}
+async function detectLanguage(projectRoot, pkg) {
+  const deps = { ...pkg?.dependencies ?? {}, ...pkg?.devDependencies ?? {} };
+  if (deps.typescript || await exists5(join12(projectRoot, "tsconfig.json"))) {
+    return "typescript";
+  }
+  return "javascript";
+}
+async function detectWorkspaces(projectRoot, pkg) {
+  const packageWorkspaces = normalizeWorkspaces(pkg?.workspaces).map((path) => ({
+    name: path,
+    path,
+    source: "package.json:workspaces"
+  }));
+  if (packageWorkspaces.length) {
+    return packageWorkspaces;
+  }
+  try {
+    const workspace = parse2(await readFile10(join12(projectRoot, "pnpm-workspace.yaml"), "utf8"));
+    return (workspace?.packages ?? []).map((path) => ({
+      name: path,
+      path,
+      source: "pnpm-workspace.yaml:packages"
+    }));
+  } catch {
+    return [];
+  }
+}
+async function detectLockManagers(projectRoot) {
+  const lockFiles = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["bun.lockb", "bun"],
+    ["bun.lock", "bun"],
+    ["package-lock.json", "npm"]
+  ];
+  const found = [];
+  for (const [file, manager] of lockFiles) {
+    if (await exists5(join12(projectRoot, file))) {
+      found.push(manager);
+    }
+  }
+  return found;
+}
+function normalizeWorkspaces(workspaces) {
+  if (Array.isArray(workspaces)) {
+    return workspaces;
+  }
+  return workspaces?.packages ?? [];
+}
+function scriptCommand(packageManager, name) {
+  return packageManager === "npm" ? `npm run ${name}` : `${packageManager} ${name}`;
+}
+async function exists5(path) {
+  try {
+    await stat7(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/routes.ts
+import { readdir as readdir2, stat as stat8 } from "fs/promises";
+import { join as join13, relative, sep } from "path";
+async function scanRoutes(projectRoot) {
+  const candidates = ["src/routes", "src/pages", "app", "pages"];
+  const routes = [];
+  for (const candidate of candidates) {
+    const root = join13(projectRoot, candidate);
+    if (!await exists6(root)) {
+      continue;
+    }
+    for (const file of await listFiles(root)) {
+      if (!/\.(tsx?|jsx?|vue|svelte)$/.test(file)) {
+        continue;
+      }
+      routes.push({
+        path: inferRoutePath(relative(root, file)),
+        source: relative(projectRoot, file).split(sep).join("/"),
+        inferred: true,
+        confidence: "medium"
+      });
+    }
+  }
+  return routes.slice(0, 100);
+}
+function inferRoutePath(relativePath) {
+  const normalized = relativePath.split(sep).join("/");
+  const withoutExt = normalized.replace(/\.(tsx?|jsx?|vue|svelte)$/, "");
+  const withoutIndex = withoutExt.replace(/\/index$/, "").replace(/^index$/, "");
+  return `/${withoutIndex}`.replace(/\/+/g, "/");
+}
+async function listFiles(root) {
+  const entries = await readdir2(root, { withFileTypes: true });
+  const files = [];
+  for (const entry of entries) {
+    const path = join13(root, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...await listFiles(path));
+    } else {
+      files.push(path);
+    }
+  }
+  return files;
+}
+async function exists6(path) {
+  try {
+    await stat8(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/scanner/index.ts
+var ProjectScanner = class {
+  async scan(projectRoot, _options = {}) {
+    const pkg = await readPackageJson(projectRoot);
+    const packageManager = await detectPackageManager(projectRoot, pkg);
+    const framework = detectFramework(pkg);
+    const workspaces = await detectWorkspaces(projectRoot, pkg);
+    const language = await detectLanguage(projectRoot, pkg);
+    const warnings = [...packageManager.warnings];
+    if (framework.name === "unknown") {
+      warnings.push("\u672A\u80FD\u4ECE package.json \u8BC6\u522B\u4E3B\u8981\u6846\u67B6");
+    }
+    return {
+      generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      scannerVersion: 1,
+      project: {
+        name: pkg?.name ?? "unknown",
+        packageManager: packageManager.manager,
+        packageManagerConfidence: packageManager.confidence,
+        framework,
+        language,
+        monorepo: workspaces.length > 0,
+        workspaces
+      },
+      commands: extractCommands(pkg, packageManager.manager),
+      routes: await scanRoutes(projectRoot),
+      conventions: [],
+      skippedFiles: [],
+      warnings
+    };
+  }
+};
+
+// src/cli/output.ts
+var OutputWriter = class {
+  constructor(json) {
+    this.json = json;
+  }
+  json;
+  info(message, details) {
+    if (!this.json) {
+      process.stdout.write(`${message}${formatDetails(details)}
+`);
+    }
+  }
+  warn(message, details) {
+    if (!this.json) {
+      process.stderr.write(`\u8B66\u544A\uFF1A${message}${formatDetails(details)}
+`);
+    }
+  }
+  error(error) {
+    if (this.json) {
+      process.stderr.write(`${JSON.stringify({ ok: false, error: error.toJSON() }, null, 2)}
+`);
+      return;
+    }
+    process.stderr.write(`FET \u65E0\u6CD5\u7EE7\u7EED\uFF1A${error.message}
+`);
+    if (error.details !== void 0) {
+      process.stderr.write(`
+\u8BE6\u60C5\uFF1A
+${formatBlock(error.details)}
+`);
+    }
+    if (error.suggestedCommand) {
+      process.stderr.write(`
+\u5EFA\u8BAE\uFF1A
+  ${error.suggestedCommand}
+`);
+    }
+  }
+  result(result) {
+    if (this.json) {
+      process.stdout.write(`${JSON.stringify(result, null, 2)}
+`);
+      return;
+    }
+    process.stdout.write(`${result.summary}
+`);
+    for (const warning of result.warnings ?? []) {
+      process.stdout.write(`\u8B66\u544A\uFF1A${warning}
+`);
+    }
+    if (result.nextSteps?.length) {
+      process.stdout.write("\n\u4E0B\u4E00\u6B65\uFF1A\n");
+      for (const step of result.nextSteps) {
+        process.stdout.write(`  ${step}
+`);
+      }
+    }
+  }
+};
+function formatDetails(details) {
+  if (details === void 0) {
+    return "";
+  }
+  return ` ${JSON.stringify(details)}`;
+}
+function formatBlock(details) {
+  if (typeof details === "string") {
+    return `  ${details}`;
+  }
+  return JSON.stringify(details, null, 2).split("\n").map((line) => `  ${line}`).join("\n");
+}
+
+// src/cli/context.ts
+async function createCommandContext(command, options) {
+  const projectRoot = resolve(options.cwd ?? process.cwd());
+  const project = await detectProjectIdentity(projectRoot);
+  const output = new OutputWriter(Boolean(options.json));
+  return {
+    command,
+    cwd: projectRoot,
+    projectRoot,
+    isTty: Boolean(process.stdout.isTTY),
+    json: Boolean(options.json),
+    verbose: Boolean(options.verbose),
+    yes: Boolean(options.yes),
+    changeId: options.change,
+    fetVersion: FET_VERSION,
+    output,
+    stateStore: new StateStore(projectRoot, FET_VERSION, project),
+    openSpec: new DefaultOpenSpecAdapter(),
+    scanner: new ProjectScanner(),
+    toolAdapters: [new CursorAdapter()]
+  };
+}
+
+// src/cli/index.ts
+var program = new Command();
+program.name("fet").description("Frontend workflow orchestration tool built around OpenSpec.").enablePositionalOptions().version(FET_VERSION).option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
+addGlobalOptions(program.command("init")).description("\u521D\u59CB\u5316 FET + OpenSpec").action(wrap("init", initCommand));
+addGlobalOptions(program.command("update-context")).description("\u66F4\u65B0\u9879\u76EE\u4E0A\u4E0B\u6587").action(wrap("update-context", updateContextCommand));
+addGlobalOptions(program.command("doctor").description("\u8BCA\u65AD\u72B6\u6001\u3001\u914D\u7F6E\u4E0E\u4E00\u81F4\u6027").option("--fix-lock", "\u6E05\u7406 FET \u9501\u6587\u4EF6")).action(
+  wrap("doctor", (ctx, options) => doctorCommand(ctx, { fixLock: Boolean(options.fixLock) }))
+);
+addGlobalOptions(program.command("verify").description("\u6700\u7EC8\u8D28\u91CF\u9A8C\u8BC1").option("--done", "\u58F0\u660E\u624B\u52A8\u9A8C\u8BC1\u5DF2\u5B8C\u6210").option("--auto", "\u751F\u6210\u6216\u6267\u884C\u81EA\u52A8\u9A8C\u8BC1\u8BA1\u5212")).action(wrap("verify", verifyCommand));
+for (const command of ["explore", "propose", "new", "continue", "ff", "apply", "sync", "archive", "bulk-archive", "onboard"]) {
+  addGlobalOptions(program.command(`${command} [args...]`).description(`\u4EE3\u7406\u6267\u884C openspec ${command}`).allowUnknownOption(true).passThroughOptions()).action(wrap(command, (ctx, args = []) => proxyCommand(ctx, command, args)));
+}
+addGlobalOptions(program.command("passthrough <command> [args...]").description("\u900F\u4F20\u6682\u672A\u63A5\u7BA1\u7684 OpenSpec \u547D\u4EE4").allowUnknownOption(true).passThroughOptions()).action(wrap("passthrough", (ctx, command, args = []) => passthroughCommand(ctx, command, args)));
+program.parseAsync(process.argv).catch((error) => {
+  const json = process.argv.includes("--json");
+  const output = new OutputWriter(json);
+  const fetError = toFetError(error);
+  output.error(fetError);
+  process.exitCode = fetError.exitCode;
+});
+function wrap(command, handler) {
+  return async (...args) => {
+    const maybeCommand = args[args.length - 1];
+    const opts = isCommandLike(maybeCommand) ? { ...maybeCommand.parent?.opts(), ...maybeCommand.opts() } : program.opts();
+    const ctx = await createCommandContext(command, { ...opts, ...extractGlobalOptions(args) });
+    try {
+      await handler(ctx, ...args);
+    } catch (error) {
+      const fetError = toFetError(error);
+      ctx.output.error(fetError);
+      process.exitCode = fetError.exitCode;
+    }
+  };
+}
+function isCommandLike(value) {
+  return value instanceof Command;
+}
+function addGlobalOptions(command) {
+  return command.option("--cwd <path>", "\u6307\u5B9A\u9879\u76EE\u6839\u76EE\u5F55").option("--change <id>", "\u6307\u5B9A OpenSpec change").option("--yes", "\u5BF9\u4F4E\u98CE\u9669\u786E\u8BA4\u4F7F\u7528\u9ED8\u8BA4\u540C\u610F").option("--json", "\u8F93\u51FA\u673A\u5668\u53EF\u8BFB JSON").option("--verbose", "\u8F93\u51FA\u8BCA\u65AD\u7EC6\u8282").option("--no-color", "\u7981\u7528\u7EC8\u7AEF\u989C\u8272");
+}
+function extractGlobalOptions(args) {
+  const values = args.flatMap((arg) => Array.isArray(arg) ? arg : []);
+  const options = {};
+  for (let index = 0; index < values.length; index += 1) {
+    const value = values[index];
+    if (typeof value !== "string") {
+      continue;
+    }
+    if (value === "--cwd" && typeof values[index + 1] === "string") {
+      options.cwd = values[index + 1];
+      index += 1;
+    } else if (value.startsWith("--cwd=")) {
+      options.cwd = value.slice("--cwd=".length);
+    } else if (value === "--change" && typeof values[index + 1] === "string") {
+      options.change = values[index + 1];
+      index += 1;
+    } else if (value.startsWith("--change=")) {
+      options.change = value.slice("--change=".length);
+    } else if (value === "--yes") {
+      options.yes = true;
+    } else if (value === "--json") {
+      options.json = true;
+    } else if (value === "--verbose") {
+      options.verbose = true;
+    }
+  }
+  return options;
+}
+//# sourceMappingURL=index.js.map