@cat-kit/agent-context 1.0.7 → 1.1.1

package/src/tools.ts

@@ -0,0 +1,114 @@
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+import type { ToolId, ToolTarget } from './types.js'
+
+const SKILL_FILE_NAME = 'SKILL.md'
+const SKILL_NAME = 'ac-workflow'
+
+const TOOL_TARGET_MAP: Record<ToolId, ToolTarget> = {
+  claude: {
+    id: 'claude',
+    name: 'Claude Code',
+    skillRootDir: '.claude/skills',
+    frontmatterProfile: 'claude',
+    metadataFiles: []
+  },
+  codex: {
+    id: 'codex',
+    name: 'Codex',
+    skillRootDir: '.codex/skills',
+    frontmatterProfile: 'standard',
+    metadataFiles: ['openai']
+  },
+  cursor: {
+    id: 'cursor',
+    name: 'Cursor',
+    skillRootDir: '.cursor/skills',
+    frontmatterProfile: 'standard',
+    metadataFiles: []
+  },
+  antigravity: {
+    id: 'antigravity',
+    name: 'Antigravity',
+    skillRootDir: '.agent/skills',
+    frontmatterProfile: 'standard',
+    metadataFiles: []
+  },
+  copilot: {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    skillRootDir: '.github/skills',
+    frontmatterProfile: 'copilot',
+    metadataFiles: []
+  }
+}
+
+export const DEFAULT_TOOL_ORDER: ToolId[] = ['claude', 'codex', 'cursor', 'antigravity', 'copilot']
+
+export interface ToolChoice {
+  id: ToolId
+  name: string
+}
+
+export function getToolChoices(): ToolChoice[] {
+  return DEFAULT_TOOL_ORDER.map((id) => ({ id, name: TOOL_TARGET_MAP[id].name }))
+}
+
+export function parseToolIds(toolsText: string): ToolId[] {
+  const parsed = toolsText
+    .split(',')
+    .map((item) => item.trim().toLowerCase())
+    .filter(Boolean)
+
+  if (parsed.length === 0) {
+    return [...DEFAULT_TOOL_ORDER]
+  }
+
+  const uniqueIds: ToolId[] = []
+
+  for (const value of parsed) {
+    if (!isToolId(value)) {
+      throw new Error(`不支持的工具标识: ${value}。可选值: ${DEFAULT_TOOL_ORDER.join(', ')}`)
+    }
+
+    if (!uniqueIds.includes(value)) {
+      uniqueIds.push(value)
+    }
+  }
+
+  return uniqueIds
+}
+
+export function resolveToolTargets(tools?: ToolId[]): ToolTarget[] {
+  const selected = tools && tools.length > 0 ? tools : DEFAULT_TOOL_ORDER
+  return selected.map((id) => ({ ...TOOL_TARGET_MAP[id] }))
+}
+
+export function detectConfiguredToolIds(cwd: string): ToolId[] {
+  return DEFAULT_TOOL_ORDER.filter((toolId) => {
+    const target = TOOL_TARGET_MAP[toolId]
+    return existsSync(resolveSkillPaths(target, cwd).skillFile)
+  })
+}
+
+// ── Skill 路径解析 ───────────────────────────────────
+
+export interface SkillPaths {
+  skillDir: string
+  skillFile: string
+  openaiMetadataFile: string
+}
+
+export function resolveSkillPaths(target: ToolTarget, cwd: string): SkillPaths {
+  const skillDir = resolve(cwd, target.skillRootDir, SKILL_NAME)
+  return {
+    skillDir,
+    skillFile: resolve(skillDir, SKILL_FILE_NAME),
+    openaiMetadataFile: resolve(skillDir, 'agents/openai.yaml')
+  }
+}
+
+function isToolId(value: string): value is ToolId {
+  return Object.hasOwn(TOOL_TARGET_MAP, value)
+}

package/src/types.ts

@@ -0,0 +1,71 @@
+export type ToolId = 'claude' | 'codex' | 'cursor' | 'antigravity' | 'copilot'
+
+export type SkillFrontmatterProfile = 'standard' | 'claude' | 'copilot'
+export type SkillMetadataFile = 'openai'
+
+export interface ToolTarget {
+  id: ToolId
+  name: string
+  skillRootDir: string
+  frontmatterProfile: SkillFrontmatterProfile
+  metadataFiles: SkillMetadataFile[]
+}
+
+export interface SkillArtifacts {
+  files: Array<{
+    relativePath: string
+    body: string
+  }>
+}
+
+export interface FileMutation {
+  path: string
+  body: string
+}
+
+export interface ApplyMutationResult {
+  created: string[]
+  updated: string[]
+  unchanged: string[]
+  changed: string[]
+}
+
+export interface RunOptions {
+  cwd?: string
+  tools?: ToolId[]
+  check?: boolean
+}
+
+export interface RunResult extends ApplyMutationResult {
+  mode: 'install' | 'sync'
+  check: boolean
+}
+
+// ── Context types ────────────────────────────────────
+
+export type PlanStatus = '未执行' | '已执行'
+
+export interface PlanInfo {
+  number: number
+  status: PlanStatus
+  dir: string
+}
+
+export interface ContextSnapshot {
+  root: string
+  currentPlan: PlanInfo | null
+  preparing: PlanInfo[]
+  doneCount: number
+}
+
+export interface ValidateResult {
+  valid: boolean
+  errors: string[]
+  context: ContextSnapshot | null
+}
+
+export interface ArchiveResult {
+  archivedTo: string
+  promoted: number | null
+  remainingPreparing: number
+}

package/dist/adapters/tool-targets.js

@@ -1,2 +0,0 @@
-import{existsSync as e}from"node:fs";import{resolve as t}from"node:path";const n={claude:{id:`claude`,name:`Claude Code`,rootDir:`.claude/commands`,fileExtension:`.md`,supportsFrontmatter:!0,commandSeparator:`:`,commandPrefix:`/`},codex:{id:`codex`,name:`Codex`,rootDir:`.codex/prompts`,fileExtension:`.md`,supportsFrontmatter:!0,commandSeparator:`-`,commandPrefix:`/`},cursor:{id:`cursor`,name:`Cursor`,rootDir:`.cursor/commands`,fileExtension:`.md`,supportsFrontmatter:!1,commandSeparator:`-`,commandPrefix:`/`},antigravity:{id:`antigravity`,name:`Antigravity`,rootDir:`.agent/workflows`,fileExtension:`.md`,supportsFrontmatter:!0,commandSeparator:`-`,commandPrefix:`/`},copilot:{id:`copilot`,name:`GitHub Copilot`,rootDir:`.github/prompts`,fileExtension:`.prompt.md`,supportsFrontmatter:!0,commandSeparator:`-`,commandPrefix:`#`}},r=[`claude`,`codex`,`cursor`,`antigravity`,`copilot`],i=[`init`,`plan`,`replan`,`implement`,`patch`,`done`];function a(){return r.map(e=>({id:e,name:n[e].name}))}function o(e){let t=e.split(`,`).map(e=>e.trim().toLowerCase()).filter(Boolean);if(t.length===0)return[...r];let n=[];for(let e of t){if(!u(e))throw Error(`不支持的工具标识: ${e}。可选值: ${r.join(`, `)}`);n.includes(e)||n.push(e)}return n}function s(e){return(e&&e.length>0?e:r).map(e=>({...n[e]}))}function c(t){return r.filter(r=>{let a=n[r],o=l(a,t);return i.some(t=>e(o.commandFile(t)))})}function l(e,n){let r=t(n,e.rootDir),i=e.fileExtension;if(e.commandSeparator===`:`){let e=t(r,`ac`);return{commandFile:n=>t(e,`${n}${i}`)}}return{commandFile:e=>t(r,`ac-${e}${i}`)}}function u(e){return Object.hasOwn(n,e)}export{r as DEFAULT_TOOL_ORDER,c as detectConfiguredToolIds,a as getToolChoices,o as parseToolIds,s as resolveToolTargets,l as resolveWorkflowPaths};
-//# sourceMappingURL=tool-targets.js.map

package/dist/adapters/tool-targets.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"tool-targets.js","names":[],"sources":["../../src/adapters/tool-targets.ts"],"sourcesContent":["import { resolve } from 'node:path'\nimport { existsSync } from 'node:fs'\n\nimport type { ToolId, ToolTarget, WorkflowCommandName } from '../domain/types'\n\nconst TOOL_TARGET_MAP: Record<ToolId, ToolTarget> = {\n  claude: {\n    id: 'claude',\n    name: 'Claude Code',\n    rootDir: '.claude/commands',\n    fileExtension: '.md',\n    supportsFrontmatter: true,\n    commandSeparator: ':',\n    commandPrefix: '/'\n  },\n  codex: {\n    id: 'codex',\n    name: 'Codex',\n    rootDir: '.codex/prompts',\n    fileExtension: '.md',\n    supportsFrontmatter: true,\n    commandSeparator: '-',\n    commandPrefix: '/'\n  },\n  cursor: {\n    id: 'cursor',\n    name: 'Cursor',\n    rootDir: '.cursor/commands',\n    fileExtension: '.md',\n    supportsFrontmatter: false,\n    commandSeparator: '-',\n    commandPrefix: '/'\n  },\n  antigravity: {\n    id: 'antigravity',\n    name: 'Antigravity',\n    rootDir: '.agent/workflows',\n    fileExtension: '.md',\n    supportsFrontmatter: true,\n    commandSeparator: '-',\n    commandPrefix: '/'\n  },\n  copilot: {\n    id: 'copilot',\n    name: 'GitHub Copilot',\n    rootDir: '.github/prompts',\n    fileExtension: '.prompt.md',\n    supportsFrontmatter: true,\n    commandSeparator: '-',\n    commandPrefix: '#'\n  }\n}\n\nexport const DEFAULT_TOOL_ORDER: ToolId[] = [\n  'claude',\n  'codex',\n  'cursor',\n  'antigravity',\n  'copilot'\n]\n\nconst WORKFLOW_COMMAND_ORDER: WorkflowCommandName[] = [\n  'init',\n  'plan',\n  'replan',\n  'implement',\n  'patch',\n  'done'\n]\n\nexport interface ToolChoice {\n  id: ToolId\n  name: string\n}\n\nexport function getToolChoices(): ToolChoice[] {\n  return DEFAULT_TOOL_ORDER.map(id => ({\n    id,\n    name: TOOL_TARGET_MAP[id].name\n  }))\n}\n\nexport function parseToolIds(toolsText: string): ToolId[] {\n  const parsed = toolsText\n    .split(',')\n    .map(item => item.trim().toLowerCase())\n    .filter(Boolean)\n\n  if (parsed.length === 0) {\n    return [...DEFAULT_TOOL_ORDER]\n  }\n\n  const uniqueIds: ToolId[] = []\n\n  for (const value of parsed) {\n    if (!isToolId(value)) {\n      throw new Error(\n        `不支持的工具标识: ${value}。可选值: ${DEFAULT_TOOL_ORDER.join(', ')}`\n      )\n    }\n\n    if (!uniqueIds.includes(value)) {\n      uniqueIds.push(value)\n    }\n  }\n\n  return uniqueIds\n}\n\nexport function resolveToolTargets(tools?: ToolId[]): ToolTarget[] {\n  const selected = tools && tools.length > 0 ? tools : DEFAULT_TOOL_ORDER\n  return selected.map(id => ({ ...TOOL_TARGET_MAP[id] }))\n}\n\nexport function detectConfiguredToolIds(cwd: string): ToolId[] {\n  return DEFAULT_TOOL_ORDER.filter((toolId) => {\n    const target = TOOL_TARGET_MAP[toolId]\n    const workflowPaths = resolveWorkflowPaths(target, cwd)\n\n    return WORKFLOW_COMMAND_ORDER.some(command =>\n      existsSync(workflowPaths.commandFile(command))\n    )\n  })\n}\n\n// ── 工作流路径解析 ────────────────────────────────────\n\nexport interface WorkflowPaths {\n  commandFile(name: WorkflowCommandName): string\n}\n\n/**\n * 根据工具约束计算工作流文件输出路径\n *\n * - separator=':' (Claude) → 嵌套: .claude/commands/ac/init.md  → /ac:init\n * - separator='-' (其他)   → 扁平: .cursor/commands/ac-init.md → /ac-init\n */\nexport function resolveWorkflowPaths(target: ToolTarget, cwd: string): WorkflowPaths {\n  const root = resolve(cwd, target.rootDir)\n  const ext = target.fileExtension\n  const nested = target.commandSeparator === ':'\n\n  if (nested) {\n    const nsDir = resolve(root, 'ac')\n    return {\n      commandFile: name => resolve(nsDir, `${name}${ext}`)\n    }\n  }\n\n  return {\n    commandFile: name => resolve(root, `ac-${name}${ext}`)\n  }\n}\n\nfunction isToolId(value: string): value is ToolId {\n  return Object.hasOwn(TOOL_TARGET_MAP, value)\n}\n"],"mappings":"yEAKA,MAAM,EAA8C,CAClD,OAAQ,CACN,GAAI,SACJ,KAAM,cACN,QAAS,mBACT,cAAe,MACf,oBAAqB,GACrB,iBAAkB,IAClB,cAAe,IAChB,CACD,MAAO,CACL,GAAI,QACJ,KAAM,QACN,QAAS,iBACT,cAAe,MACf,oBAAqB,GACrB,iBAAkB,IAClB,cAAe,IAChB,CACD,OAAQ,CACN,GAAI,SACJ,KAAM,SACN,QAAS,mBACT,cAAe,MACf,oBAAqB,GACrB,iBAAkB,IAClB,cAAe,IAChB,CACD,YAAa,CACX,GAAI,cACJ,KAAM,cACN,QAAS,mBACT,cAAe,MACf,oBAAqB,GACrB,iBAAkB,IAClB,cAAe,IAChB,CACD,QAAS,CACP,GAAI,UACJ,KAAM,iBACN,QAAS,kBACT,cAAe,aACf,oBAAqB,GACrB,iBAAkB,IAClB,cAAe,IAChB,CACF,CAEY,EAA+B,CAC1C,SACA,QACA,SACA,cACA,UACD,CAEK,EAAgD,CACpD,OACA,OACA,SACA,YACA,QACA,OACD,CAOD,SAAgB,GAA+B,CAC7C,OAAO,EAAmB,IAAI,IAAO,CACnC,KACA,KAAM,EAAgB,GAAI,KAC3B,EAAE,CAGL,SAAgB,EAAa,EAA6B,CACxD,IAAM,EAAS,EACZ,MAAM,IAAI,CACV,IAAI,GAAQ,EAAK,MAAM,CAAC,aAAa,CAAC,CACtC,OAAO,QAAQ,CAElB,GAAI,EAAO,SAAW,EACpB,MAAO,CAAC,GAAG,EAAmB,CAGhC,IAAM,EAAsB,EAAE,CAE9B,IAAK,IAAM,KAAS,EAAQ,CAC1B,GAAI,CAAC,EAAS,EAAM,CAClB,MAAU,MACR,aAAa,EAAM,QAAQ,EAAmB,KAAK,KAAK,GACzD,CAGE,EAAU,SAAS,EAAM,EAC5B,EAAU,KAAK,EAAM,CAIzB,OAAO,EAGT,SAAgB,EAAmB,EAAgC,CAEjE,OADiB,GAAS,EAAM,OAAS,EAAI,EAAQ,GACrC,IAAI,IAAO,CAAE,GAAG,EAAgB,GAAK,EAAE,CAGzD,SAAgB,EAAwB,EAAuB,CAC7D,OAAO,EAAmB,OAAQ,GAAW,CAC3C,IAAM,EAAS,EAAgB,GACzB,EAAgB,EAAqB,EAAQ,EAAI,CAEvD,OAAO,EAAuB,KAAK,GACjC,EAAW,EAAc,YAAY,EAAQ,CAAC,CAC/C,EACD,CAeJ,SAAgB,EAAqB,EAAoB,EAA4B,CACnF,IAAM,EAAO,EAAQ,EAAK,EAAO,QAAQ,CACnC,EAAM,EAAO,cAGnB,GAFe,EAAO,mBAAqB,IAE/B,CACV,IAAM,EAAQ,EAAQ,EAAM,KAAK,CACjC,MAAO,CACL,YAAa,GAAQ,EAAQ,EAAO,GAAG,IAAO,IAAM,CACrD,CAGH,MAAO,CACL,YAAa,GAAQ,EAAQ,EAAM,MAAM,IAAO,IAAM,CACvD,CAGH,SAAS,EAAS,EAAgC,CAChD,OAAO,OAAO,OAAO,EAAiB,EAAM"}

package/dist/commands/setup.js

@@ -1,2 +0,0 @@
-import{DEFAULT_TOOL_ORDER as e,detectConfiguredToolIds as t,getToolChoices as n,parseToolIds as r}from"../adapters/tool-targets.js";import{runSetup as i}from"../runtime/execute.js";import{printCheckResult as a,printRunSummary as o}from"./shared.js";import{checkbox as s}from"@inquirer/prompts";async function c(e={}){let t=process.cwd(),n=await l(t,e),r=e.check??!1,s=await i({cwd:t,tools:n,check:r});if(r){a(s,t),s.changed.length>0&&(process.exitCode=1);return}o(s,t)}async function l(i,a){let o=a.tools;if(!o||o.trim().length===0){let r=t(i);return a.yes?r.length>0?r:[...e]:await s({message:`请选择要生成工作流命令的工具（可多选）：`,choices:n().map(e=>({name:e.name,value:e.id,checked:r.includes(e.id)})),required:!0})}return r(o)}export{c as setupCommand};
-//# sourceMappingURL=setup.js.map

package/dist/commands/setup.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"setup.js","names":[],"sources":["../../src/commands/setup.ts"],"sourcesContent":["import { checkbox } from '@inquirer/prompts'\n\nimport {\n  DEFAULT_TOOL_ORDER,\n  detectConfiguredToolIds,\n  getToolChoices,\n  parseToolIds\n} from '../adapters/tool-targets'\nimport type { ToolId } from '../domain/types'\nimport { runSetup } from '../runtime/execute'\nimport { printCheckResult, printRunSummary } from './shared'\n\nexport interface SetupCommandOptions {\n  tools?: string\n  check?: boolean\n  yes?: boolean\n}\n\nexport async function setupCommand(options: SetupCommandOptions = {}): Promise<void> {\n  const cwd = process.cwd()\n  const tools = await resolveTools(cwd, options)\n  const check = options.check ?? false\n\n  const result = await runSetup({ cwd, tools, check })\n\n  if (check) {\n    printCheckResult(result, cwd)\n    if (result.changed.length > 0) {\n      process.exitCode = 1\n    }\n    return\n  }\n\n  printRunSummary(result, cwd)\n}\n\nasync function resolveTools(cwd: string, options: SetupCommandOptions): Promise<ToolId[] | undefined> {\n  const raw = options.tools\n\n  if (!raw || raw.trim().length === 0) {\n    const configuredTools = detectConfiguredToolIds(cwd)\n\n    if (options.yes) {\n      if (configuredTools.length > 0) {\n        return configuredTools\n      }\n      return [...DEFAULT_TOOL_ORDER]\n    }\n\n    const selectedTools = await checkbox<ToolId>({\n      message: '请选择要生成工作流命令的工具（可多选）：',\n      choices: getToolChoices().map((tool) => ({\n        name: tool.name,\n        value: tool.id,\n        checked: configuredTools.includes(tool.id)\n      })),\n      required: true\n    })\n\n    return selectedTools\n  }\n\n  return parseToolIds(raw)\n}\n"],"mappings":"sSAkBA,eAAsB,EAAa,EAA+B,EAAE,CAAiB,CACnF,IAAM,EAAM,QAAQ,KAAK,CACnB,EAAQ,MAAM,EAAa,EAAK,EAAQ,CACxC,EAAQ,EAAQ,OAAS,GAEzB,EAAS,MAAM,EAAS,CAAE,MAAK,QAAO,QAAO,CAAC,CAEpD,GAAI,EAAO,CACT,EAAiB,EAAQ,EAAI,CACzB,EAAO,QAAQ,OAAS,IAC1B,QAAQ,SAAW,GAErB,OAGF,EAAgB,EAAQ,EAAI,CAG9B,eAAe,EAAa,EAAa,EAA6D,CACpG,IAAM,EAAM,EAAQ,MAEpB,GAAI,CAAC,GAAO,EAAI,MAAM,CAAC,SAAW,EAAG,CACnC,IAAM,EAAkB,EAAwB,EAAI,CAmBpD,OAjBI,EAAQ,IACN,EAAgB,OAAS,EACpB,EAEF,CAAC,GAAG,EAAmB,CAGV,MAAM,EAAiB,CAC3C,QAAS,uBACT,QAAS,GAAgB,CAAC,IAAK,IAAU,CACvC,KAAM,EAAK,KACX,MAAO,EAAK,GACZ,QAAS,EAAgB,SAAS,EAAK,GAAG,CAC3C,EAAE,CACH,SAAU,GACX,CAAC,CAKJ,OAAO,EAAa,EAAI"}

package/dist/commands/shared.js

@@ -1,4 +0,0 @@
-import{relative as e}from"node:path";function t(t,n){let r=t.mode===`setup`?`setup`:`update`;if(console.log(`\n✅ agent-context ${r} 完成`),t.created.length>0){console.log(`\n新增 ${t.created.length} 个文件:`);for(let r of t.created)console.log(`- ${e(n,r)}`)}if(t.updated.length>0){console.log(`\n更新 ${t.updated.length} 个文件:`);for(let r of t.updated)console.log(`- ${e(n,r)}`)}t.unchanged.length>0&&console.log(`\n无变更 ${t.unchanged.length} 个文件`)}function n(t,n){if(t.changed.length===0){console.log(`
-✅ 检查通过：无需更新`);return}console.log(`
-❌ 检查失败：以下文件需要更新`);for(let r of t.changed)console.log(`- ${e(n,r)}`)}export{n as printCheckResult,t as printRunSummary};
-//# sourceMappingURL=shared.js.map

package/dist/commands/shared.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"shared.js","names":[],"sources":["../../src/commands/shared.ts"],"sourcesContent":["import { relative } from 'node:path'\n\nimport type { RunResult } from '../domain/types'\n\nexport function printRunSummary(result: RunResult, cwd: string): void {\n  const modeTitle = result.mode === 'setup' ? 'setup' : 'update'\n  console.log(`\\n✅ agent-context ${modeTitle} 完成`) // eslint-disable-line no-console\n\n  if (result.created.length > 0) {\n    console.log(`\\n新增 ${result.created.length} 个文件:`) // eslint-disable-line no-console\n    for (const filePath of result.created) {\n      console.log(`- ${relative(cwd, filePath)}`) // eslint-disable-line no-console\n    }\n  }\n\n  if (result.updated.length > 0) {\n    console.log(`\\n更新 ${result.updated.length} 个文件:`) // eslint-disable-line no-console\n    for (const filePath of result.updated) {\n      console.log(`- ${relative(cwd, filePath)}`) // eslint-disable-line no-console\n    }\n  }\n\n  if (result.unchanged.length > 0) {\n    console.log(`\\n无变更 ${result.unchanged.length} 个文件`) // eslint-disable-line no-console\n  }\n}\n\nexport function printCheckResult(result: RunResult, cwd: string): void {\n  if (result.changed.length === 0) {\n    console.log('\\n✅ 检查通过：无需更新') // eslint-disable-line no-console\n    return\n  }\n\n  console.log('\\n❌ 检查失败：以下文件需要更新') // eslint-disable-line no-console\n  for (const filePath of result.changed) {\n    console.log(`- ${relative(cwd, filePath)}`) // eslint-disable-line no-console\n  }\n}\n"],"mappings":"qCAIA,SAAgB,EAAgB,EAAmB,EAAmB,CACpE,IAAM,EAAY,EAAO,OAAS,QAAU,QAAU,SAGtD,GAFA,QAAQ,IAAI,qBAAqB,EAAU,KAAK,CAE5C,EAAO,QAAQ,OAAS,EAAG,CAC7B,QAAQ,IAAI,QAAQ,EAAO,QAAQ,OAAO,OAAO,CACjD,IAAK,IAAM,KAAY,EAAO,QAC5B,QAAQ,IAAI,KAAK,EAAS,EAAK,EAAS,GAAG,CAI/C,GAAI,EAAO,QAAQ,OAAS,EAAG,CAC7B,QAAQ,IAAI,QAAQ,EAAO,QAAQ,OAAO,OAAO,CACjD,IAAK,IAAM,KAAY,EAAO,QAC5B,QAAQ,IAAI,KAAK,EAAS,EAAK,EAAS,GAAG,CAI3C,EAAO,UAAU,OAAS,GAC5B,QAAQ,IAAI,SAAS,EAAO,UAAU,OAAO,MAAM,CAIvD,SAAgB,EAAiB,EAAmB,EAAmB,CACrE,GAAI,EAAO,QAAQ,SAAW,EAAG,CAC/B,QAAQ,IAAI;aAAgB,CAC5B,OAGF,QAAQ,IAAI;iBAAoB,CAChC,IAAK,IAAM,KAAY,EAAO,QAC5B,QAAQ,IAAI,KAAK,EAAS,EAAK,EAAS,GAAG"}

package/dist/commands/update.js

@@ -1,2 +0,0 @@
-import{detectConfiguredToolIds as e,parseToolIds as t}from"../adapters/tool-targets.js";import{runUpdate as n}from"../runtime/execute.js";import{printCheckResult as r,printRunSummary as i}from"./shared.js";async function a(e={}){let t=process.cwd(),a=o(t,e.tools),s=e.check??!1,c=await n({cwd:t,tools:a,check:s});if(s){r(c,t),c.changed.length>0&&(process.exitCode=1);return}i(c,t)}function o(n,r){if(!r||r.trim().length===0){let t=e(n);if(t.length===0)throw Error(`未检测到已 setup 的工具，请先执行 setup 或通过 --tools 显式指定工具`);return t}return t(r)}export{a as updateCommand};
-//# sourceMappingURL=update.js.map

package/dist/commands/update.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"update.js","names":[],"sources":["../../src/commands/update.ts"],"sourcesContent":["import { detectConfiguredToolIds, parseToolIds } from '../adapters/tool-targets'\nimport type { ToolId } from '../domain/types'\nimport { runUpdate } from '../runtime/execute'\nimport { printCheckResult, printRunSummary } from './shared'\n\nexport interface UpdateCommandOptions {\n  tools?: string\n  check?: boolean\n  yes?: boolean\n}\n\nexport async function updateCommand(options: UpdateCommandOptions = {}): Promise<void> {\n  const cwd = process.cwd()\n  const tools = resolveTools(cwd, options.tools)\n  const check = options.check ?? false\n\n  const result = await runUpdate({\n    cwd,\n    tools,\n    check\n  })\n\n  if (check) {\n    printCheckResult(result, cwd)\n    if (result.changed.length > 0) {\n      process.exitCode = 1\n    }\n    return\n  }\n\n  printRunSummary(result, cwd)\n}\n\nfunction resolveTools(cwd: string, raw?: string): ToolId[] | undefined {\n  if (!raw || raw.trim().length === 0) {\n    const configuredTools = detectConfiguredToolIds(cwd)\n\n    if (configuredTools.length === 0) {\n      throw new Error('未检测到已 setup 的工具，请先执行 setup 或通过 --tools 显式指定工具')\n    }\n\n    return configuredTools\n  }\n\n  return parseToolIds(raw)\n}\n"],"mappings":"8MAWA,eAAsB,EAAc,EAAgC,EAAE,CAAiB,CACrF,IAAM,EAAM,QAAQ,KAAK,CACnB,EAAQ,EAAa,EAAK,EAAQ,MAAM,CACxC,EAAQ,EAAQ,OAAS,GAEzB,EAAS,MAAM,EAAU,CAC7B,MACA,QACA,QACD,CAAC,CAEF,GAAI,EAAO,CACT,EAAiB,EAAQ,EAAI,CACzB,EAAO,QAAQ,OAAS,IAC1B,QAAQ,SAAW,GAErB,OAGF,EAAgB,EAAQ,EAAI,CAG9B,SAAS,EAAa,EAAa,EAAoC,CACrE,GAAI,CAAC,GAAO,EAAI,MAAM,CAAC,SAAW,EAAG,CACnC,IAAM,EAAkB,EAAwB,EAAI,CAEpD,GAAI,EAAgB,SAAW,EAC7B,MAAU,MAAM,gDAAgD,CAGlE,OAAO,EAGT,OAAO,EAAa,EAAI"}

package/dist/domain/workflow-content.js

@@ -1,2 +0,0 @@
-import{createWorkflowContext as e}from"./workflow-context.js";import{renderInit as t}from"./workflow-templates/init.js";import{renderPlan as n}from"./workflow-templates/plan.js";import{renderReplan as r}from"./workflow-templates/replan.js";import{renderImplement as i}from"./workflow-templates/implement.js";import{renderPatch as a}from"./workflow-templates/patch.js";import{renderDone as o}from"./workflow-templates/done.js";function s(s){let c=e(s);return{commandFiles:{init:t(c),plan:n(c),replan:r(c),implement:i(c),patch:a(c),done:o(c)}}}export{s as renderWorkflowArtifacts};
-//# sourceMappingURL=workflow-content.js.map

package/dist/domain/workflow-content.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-content.js","names":[],"sources":["../../src/domain/workflow-content.ts"],"sourcesContent":["import type { ToolTarget, WorkflowArtifacts } from './types'\nimport {\n  createWorkflowContext,\n  renderDone,\n  renderImplement,\n  renderInit,\n  renderPatch,\n  renderPlan,\n  renderReplan\n} from './workflow-templates/index.js'\n\nexport function renderWorkflowArtifacts(target: ToolTarget): WorkflowArtifacts {\n  const ctx = createWorkflowContext(target)\n\n  return {\n    commandFiles: {\n      init: renderInit(ctx),\n      plan: renderPlan(ctx),\n      replan: renderReplan(ctx),\n      implement: renderImplement(ctx),\n      patch: renderPatch(ctx),\n      done: renderDone(ctx)\n    }\n  }\n}\n"],"mappings":"0aAWA,SAAgB,EAAwB,EAAuC,CAC7E,IAAM,EAAM,EAAsB,EAAO,CAEzC,MAAO,CACL,aAAc,CACZ,KAAM,EAAW,EAAI,CACrB,KAAM,EAAW,EAAI,CACrB,OAAQ,EAAa,EAAI,CACzB,UAAW,EAAgB,EAAI,CAC/B,MAAO,EAAY,EAAI,CACvB,KAAM,EAAW,EAAI,CACtB,CACF"}

package/dist/domain/workflow-context.js

@@ -1,2 +0,0 @@
-function e(e){let t=e.commandSeparator,n=e.commandPrefix;return{cmd:e=>`ac${t}${e}`,invoke:e=>`${n}ac${t}${e}`,cmdPrefix:()=>`ac${t}`,frontmatter:t=>e.supportsFrontmatter?`---\ndescription: ${t}\n---\n\n`:``}}const t="```",n=e=>`\`${e}\``;function r(e,t){return`> **下一步：** ${t.map(t=>`${n(e.invoke(t.command))}（${t.description}）`).join(` | `)}`}const i=[`init`,`plan`,`replan`,`implement`,`patch`,`done`];function a(e,t,r){return`${r}\n\n生命周期: ${i.map(r=>{let i=n(e.cmd(r));return r===t?`**${i}**`:i}).join(` → `)}。`}export{n as code,e as createWorkflowContext,t as fence,r as renderNextSteps,a as renderPreamble};
-//# sourceMappingURL=workflow-context.js.map

package/dist/domain/workflow-context.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow-context.js","names":[],"sources":["../../src/domain/workflow-context.ts"],"sourcesContent":["import type { ToolTarget } from './types'\n\nexport interface WorkflowContext {\n  /** 命令引用: 'ac:init' | 'ac-init' */\n  cmd(name: string): string\n  /** 命令调用: '/ac:init' | '#ac-init' */\n  invoke(name: string): string\n  /** 命令前缀模式: 'ac:' | 'ac-' */\n  cmdPrefix(): string\n  /** 生成 YAML frontmatter 或空字符串 */\n  frontmatter(description: string): string\n}\n\nexport function createWorkflowContext(target: ToolTarget): WorkflowContext {\n  const sep = target.commandSeparator\n  const pre = target.commandPrefix\n  return {\n    cmd: (name) => `ac${sep}${name}`,\n    invoke: (name) => `${pre}ac${sep}${name}`,\n    cmdPrefix: () => `ac${sep}`,\n    frontmatter: (desc) => (target.supportsFrontmatter ? `---\\ndescription: ${desc}\\n---\\n\\n` : '')\n  }\n}\n\nexport const fence = '```'\nexport const code = (t: string) => `\\`${t}\\``\n\nexport interface NextStep {\n  command: string\n  description: string\n}\n\nexport function renderNextSteps(c: WorkflowContext, steps: NextStep[]): string {\n  const items = steps.map((s) => `${code(c.invoke(s.command))}（${s.description}）`).join(' | ')\n\n  return `> **下一步：** ${items}`\n}\n\nconst LIFECYCLE_COMMANDS = ['init', 'plan', 'replan', 'implement', 'patch', 'done'] as const\n\nexport function renderPreamble(c: WorkflowContext, current: string, description: string): string {\n  const lifecycle = LIFECYCLE_COMMANDS.map((cmd) => {\n    const ref = code(c.cmd(cmd))\n    return cmd === current ? `**${ref}**` : ref\n  }).join(' → ')\n\n  return `${description}\\n\\n生命周期: ${lifecycle}。`\n}\n"],"mappings":"AAaA,SAAgB,EAAsB,EAAqC,CACzE,IAAM,EAAM,EAAO,iBACb,EAAM,EAAO,cACnB,MAAO,CACL,IAAM,GAAS,KAAK,IAAM,IAC1B,OAAS,GAAS,GAAG,EAAI,IAAI,IAAM,IACnC,cAAiB,KAAK,IACtB,YAAc,GAAU,EAAO,oBAAsB,qBAAqB,EAAK,WAAa,GAC7F,CAGH,MAAa,EAAQ,MACR,EAAQ,GAAc,KAAK,EAAE,IAO1C,SAAgB,EAAgB,EAAoB,EAA2B,CAG7E,MAAO,cAFO,EAAM,IAAK,GAAM,GAAG,EAAK,EAAE,OAAO,EAAE,QAAQ,CAAC,CAAC,GAAG,EAAE,YAAY,GAAG,CAAC,KAAK,MAAM,GAK9F,MAAM,EAAqB,CAAC,OAAQ,OAAQ,SAAU,YAAa,QAAS,OAAO,CAEnF,SAAgB,EAAe,EAAoB,EAAiB,EAA6B,CAM/F,MAAO,GAAG,EAAY,YALJ,EAAmB,IAAK,GAAQ,CAChD,IAAM,EAAM,EAAK,EAAE,IAAI,EAAI,CAAC,CAC5B,OAAO,IAAQ,EAAU,KAAK,EAAI,IAAM,GACxC,CAAC,KAAK,MAAM,CAE8B"}

package/dist/domain/workflow-templates/done.js

@@ -1,23 +0,0 @@
-import{code as e,renderNextSteps as t,renderPreamble as n}from"../workflow-context.js";function r(r){return`${r.frontmatter(`将当前已执行计划标记为真正完成并归档，必要时晋升 preparing 队列`)}\
-# ${r.invoke(`done`)}
-
-${n(r,`done`,`确认当前已执行计划真正完成，归档到 ${e(`.agent-context/done/`)} 目录，并自动晋升 ${e(`preparing/`)} 队列中的下一个计划。`)}
-
-## 前置规则
-
-- 带描述 → 拒绝执行。
-- 当前计划不存在 → 拒绝执行，提示先运行 ${e(r.cmd(`plan`))}。
-- 当前计划状态为 ${e(`未执行`)} → 拒绝执行，提示先运行 ${e(r.cmd(`implement`))}。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 必须得到用户确认后才可归档；用户未确认 → 中止。
-
-## 执行步骤
-
-1. **用户确认**：向用户确认当前计划已真正完成，可以归档。
-2. **归档当前计划**：将 ${e(`.agent-context/plan-{number}`)} 移动到 ${e(`.agent-context/done/plan-{number}-{YYYYMMDD}`)}（当日日期），包含完整 ${e(`plan.md`)} 与所有 ${e(`patch-{number}.md`)}。编号不可被新计划复用。
-3. **晋升 preparing 队列**：若 ${e(`.agent-context/preparing/`)} 非空，将最小编号计划移至 ${e(`.agent-context/`)} 作为新当前计划。
-4. **校验**：确认归档完整，晋升后仍满足单当前计划约束；失败则回滚。
-5. **输出反馈**：报告归档路径、是否晋升及晋升编号、是否还有待执行计划。
-
-${t(r,[{command:`plan`,description:`创建新计划`}])}`}export{r as renderDone};
-//# sourceMappingURL=done.js.map

package/dist/domain/workflow-templates/done.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"done.js","names":[],"sources":["../../../src/domain/workflow-templates/done.ts"],"sourcesContent":["import { code, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'\n\nexport function renderDone(c: WorkflowContext): string {\n  return `${c.frontmatter('将当前已执行计划标记为真正完成并归档，必要时晋升 preparing 队列')}\\\n# ${c.invoke('done')}\n\n${renderPreamble(c, 'done', `确认当前已执行计划真正完成，归档到 ${code('.agent-context/done/')} 目录，并自动晋升 ${code('preparing/')} 队列中的下一个计划。`)}\n\n## 前置规则\n\n- 带描述 → 拒绝执行。\n- 当前计划不存在 → 拒绝执行，提示先运行 ${code(c.cmd('plan'))}。\n- 当前计划状态为 ${code('未执行')} → 拒绝执行，提示先运行 ${code(c.cmd('implement'))}。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 必须得到用户确认后才可归档；用户未确认 → 中止。\n\n## 执行步骤\n\n1. **用户确认**：向用户确认当前计划已真正完成，可以归档。\n2. **归档当前计划**：将 ${code('.agent-context/plan-{number}')} 移动到 ${code('.agent-context/done/plan-{number}-{YYYYMMDD}')}（当日日期），包含完整 ${code('plan.md')} 与所有 ${code('patch-{number}.md')}。编号不可被新计划复用。\n3. **晋升 preparing 队列**：若 ${code('.agent-context/preparing/')} 非空，将最小编号计划移至 ${code('.agent-context/')} 作为新当前计划。\n4. **校验**：确认归档完整，晋升后仍满足单当前计划约束；失败则回滚。\n5. **输出反馈**：报告归档路径、是否晋升及晋升编号、是否还有待执行计划。\n\n${renderNextSteps(c, [\n  { command: 'plan', description: '创建新计划' }\n])}`\n}\n"],"mappings":"uFAEA,SAAgB,EAAW,EAA4B,CACrD,MAAO,GAAG,EAAE,YAAY,wCAAwC,CAAC;IAC/D,EAAE,OAAO,OAAO,CAAC;;EAEnB,EAAe,EAAG,OAAQ,qBAAqB,EAAK,uBAAuB,CAAC,YAAY,EAAK,aAAa,CAAC,aAAa,CAAC;;;;;yBAKlG,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;YACjC,EAAK,MAAM,CAAC,gBAAgB,EAAK,EAAE,IAAI,YAAY,CAAC,CAAC;;;;;;;kBAO/C,EAAK,+BAA+B,CAAC,OAAO,EAAK,+CAA+C,CAAC,cAAc,EAAK,UAAU,CAAC,OAAO,EAAK,oBAAoB,CAAC;2BACvJ,EAAK,4BAA4B,CAAC,gBAAgB,EAAK,kBAAkB,CAAC;;;;EAInG,EAAgB,EAAG,CACnB,CAAE,QAAS,OAAQ,YAAa,QAAS,CAC1C,CAAC"}

package/dist/domain/workflow-templates/implement.js

@@ -1,35 +0,0 @@
-import{code as e,fence as t,renderNextSteps as n,renderPreamble as r}from"../workflow-context.js";function i(i){return`${i.frontmatter(`实施当前计划并将状态从未执行更新为已执行`)}\
-# ${i.invoke(`implement`)}
-
-${r(i,`implement`,`实施当前计划 ${e(`.agent-context/plan-{number}/plan.md`)} 中的全部步骤，通过验证循环后将状态从「未执行」更新为「已执行」。`)}
-
-## 前置规则
-
-- 带描述 → 拒绝执行。
-- 当前计划不存在 → 拒绝执行，提示先运行 ${e(i.cmd(`plan`))}。
-- 当前计划状态为 ${e(`已执行`)} → 拒绝执行，提示使用 ${e(i.cmd(`patch`))} 或 ${e(i.cmd(`done`))}。
-- ${e(`## 目标`)} 或 ${e(`## 内容`)} 为空 → 拒绝执行，提示补充内容。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 仅操作当前计划，不直接操作 ${e(`preparing/`)} 中的计划。
-- 遇到阻塞问题应向用户报告，不可静默跳过。
-
-## 执行步骤
-
-1. 读取当前计划 ${e(`plan.md`)}，理解 ${e(`## 目标`)} 与 ${e(`## 内容`)}。
-2. 依据 ${e(`## 内容`)} 中的步骤逐项实施。
-3. **验证循环**（全部通过前不可进入步骤 4）：
-   a. 逐项对照 ${e(`## 内容`)} 确认每个步骤已实施。
-   b. 运行项目验证：类型检查 → lint → 测试。
-   c. 若存在失败项 → 修复后回到 a 重新验证。
-   d. 全部通过 → 进入步骤 4。
-4. 更新 ${e(`plan.md`)} 状态行：${e(`> 状态: 未执行`)} → ${e(`> 状态: 已执行`)}。状态行须唯一，仅在验证通过后更新。
-5. 更新 ${e(`## 影响范围`)}，记录所有变更文件：
-
-   ${t}markdown
-   - 新增文件: ${e(`/path/to/new-file`)}
-   - 修改文件: ${e(`/path/to/modified-file`)}
-   - 删除文件: ${e(`/path/to/deleted-file`)}
-   ${t}
-
-${n(i,[{command:`done`,description:`归档当前计划`},{command:`patch`,description:`补丁修复`}])}`}export{i as renderImplement};
-//# sourceMappingURL=implement.js.map

package/dist/domain/workflow-templates/implement.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"implement.js","names":[],"sources":["../../../src/domain/workflow-templates/implement.ts"],"sourcesContent":["import { code, fence, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'\n\nexport function renderImplement(c: WorkflowContext): string {\n  return `${c.frontmatter('实施当前计划并将状态从未执行更新为已执行')}\\\n# ${c.invoke('implement')}\n\n${renderPreamble(c, 'implement', `实施当前计划 ${code('.agent-context/plan-{number}/plan.md')} 中的全部步骤，通过验证循环后将状态从「未执行」更新为「已执行」。`)}\n\n## 前置规则\n\n- 带描述 → 拒绝执行。\n- 当前计划不存在 → 拒绝执行，提示先运行 ${code(c.cmd('plan'))}。\n- 当前计划状态为 ${code('已执行')} → 拒绝执行，提示使用 ${code(c.cmd('patch'))} 或 ${code(c.cmd('done'))}。\n- ${code('## 目标')} 或 ${code('## 内容')} 为空 → 拒绝执行，提示补充内容。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 仅操作当前计划，不直接操作 ${code('preparing/')} 中的计划。\n- 遇到阻塞问题应向用户报告，不可静默跳过。\n\n## 执行步骤\n\n1. 读取当前计划 ${code('plan.md')}，理解 ${code('## 目标')} 与 ${code('## 内容')}。\n2. 依据 ${code('## 内容')} 中的步骤逐项实施。\n3. **验证循环**（全部通过前不可进入步骤 4）：\n   a. 逐项对照 ${code('## 内容')} 确认每个步骤已实施。\n   b. 运行项目验证：类型检查 → lint → 测试。\n   c. 若存在失败项 → 修复后回到 a 重新验证。\n   d. 全部通过 → 进入步骤 4。\n4. 更新 ${code('plan.md')} 状态行：${code('> 状态: 未执行')} → ${code('> 状态: 已执行')}。状态行须唯一，仅在验证通过后更新。\n5. 更新 ${code('## 影响范围')}，记录所有变更文件：\n\n   ${fence}markdown\n   - 新增文件: ${code('/path/to/new-file')}\n   - 修改文件: ${code('/path/to/modified-file')}\n   - 删除文件: ${code('/path/to/deleted-file')}\n   ${fence}\n\n${renderNextSteps(c, [\n  { command: 'done', description: '归档当前计划' },\n  { command: 'patch', description: '补丁修复' }\n])}`\n}\n"],"mappings":"kGAEA,SAAgB,EAAgB,EAA4B,CAC1D,MAAO,GAAG,EAAE,YAAY,uBAAuB,CAAC;IAC9C,EAAE,OAAO,YAAY,CAAC;;EAExB,EAAe,EAAG,YAAa,UAAU,EAAK,uCAAuC,CAAC,mCAAmC,CAAC;;;;;yBAKnG,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;YACjC,EAAK,MAAM,CAAC,eAAe,EAAK,EAAE,IAAI,QAAQ,CAAC,CAAC,KAAK,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;IACjF,EAAK,QAAQ,CAAC,KAAK,EAAK,QAAQ,CAAC;;kBAEnB,EAAK,aAAa,CAAC;;;;;YAKzB,EAAK,UAAU,CAAC,MAAM,EAAK,QAAQ,CAAC,KAAK,EAAK,QAAQ,CAAC;QAC3D,EAAK,QAAQ,CAAC;;aAET,EAAK,QAAQ,CAAC;;;;QAInB,EAAK,UAAU,CAAC,OAAO,EAAK,YAAY,CAAC,KAAK,EAAK,YAAY,CAAC;QAChE,EAAK,UAAU,CAAC;;KAEnB,EAAM;aACE,EAAK,oBAAoB,CAAC;aAC1B,EAAK,yBAAyB,CAAC;aAC/B,EAAK,wBAAwB,CAAC;KACtC,EAAM;;EAET,EAAgB,EAAG,CACnB,CAAE,QAAS,OAAQ,YAAa,SAAU,CAC1C,CAAE,QAAS,QAAS,YAAa,OAAQ,CAC1C,CAAC"}

package/dist/domain/workflow-templates/init.js

@@ -1,37 +0,0 @@
-import{code as e,renderNextSteps as t,renderPreamble as n}from"../workflow-context.js";function r(r){return`${r.frontmatter(`初始化项目上下文，按新旧项目规则处理 AGENTS.md 与计划入口`)}\
-# ${r.invoke(`init`)} {描述?}
-
-${n(r,`init`,`初始化项目的 Agent Context 工作流上下文。根据新旧项目类型处理 ${e(`AGENTS.md`)}，新项目会自动进入 ${e(r.cmd(`plan`))} 计划创建流程。`)}
-
-描述为可选参数，用于补充项目背景、技术栈、特殊约束。
-
-## 执行步骤
-
-1. **判断项目类型**：检测根目录是否存在有效代码文件和目录结构。
-   - 新项目：无实质代码，或用户明确说明是新项目。
-   - 旧项目：已有代码、配置文件和目录结构。
-   - 无法判断 → 向用户提问澄清，不可假设。
-
-2. **处理 AGENTS.md**：
-   - 新项目：
-     1. 通过提问澄清以下要点（已从描述中获取的可跳过）：项目目标与核心功能、技术栈与版本、代码规范与工具链（lint/formatter/测试）、目录结构偏好。
-     2. 生成高质量 ${e(`AGENTS.md`)}（须满足下方质量标准，不满足则重新优化直至满足）。
-     3. 继续执行 ${e(r.cmd(`plan`))} 创建初始计划。
-   - 旧项目：
-     1. 若不存在 ${e(`AGENTS.md`)}：通过提问与代码阅读收集信息后生成。
-     2. 若已存在 ${e(`AGENTS.md`)}：按质量标准评估，不足时增补优化。
-     3. 默认不创建计划（除非用户明确要求）。
-
-3. **输出反馈**：向用户报告项目类型判定结果、AGENTS.md 处理结果、是否需要后续 ${e(r.cmd(`plan`))}。
-
-## 高质量 AGENTS.md 标准
-
-- [ ] 常用命令与约束前置，降低代理执行歧义。
-- [ ] 明确列出目录结构（至少到第二层）。
-- [ ] 明确标注技术栈及版本。
-- [ ] 明确代码风格约束（命名规范、格式化工具、lint 配置）。
-- [ ] 内容精简，无冗余段落或模板化填充。
-- [ ] 大型单体仓库按子包拆分维护本地 ${e(`AGENTS.md`)}。
-
-${t(r,[{command:`plan`,description:`创建新计划`}])}`}export{r as renderInit};
-//# sourceMappingURL=init.js.map

package/dist/domain/workflow-templates/init.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"init.js","names":[],"sources":["../../../src/domain/workflow-templates/init.ts"],"sourcesContent":["import { code, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'\n\nexport function renderInit(c: WorkflowContext): string {\n  return `${c.frontmatter('初始化项目上下文，按新旧项目规则处理 AGENTS.md 与计划入口')}\\\n# ${c.invoke('init')} {描述?}\n\n${renderPreamble(c, 'init', `初始化项目的 Agent Context 工作流上下文。根据新旧项目类型处理 ${code('AGENTS.md')}，新项目会自动进入 ${code(c.cmd('plan'))} 计划创建流程。`)}\n\n描述为可选参数，用于补充项目背景、技术栈、特殊约束。\n\n## 执行步骤\n\n1. **判断项目类型**：检测根目录是否存在有效代码文件和目录结构。\n   - 新项目：无实质代码，或用户明确说明是新项目。\n   - 旧项目：已有代码、配置文件和目录结构。\n   - 无法判断 → 向用户提问澄清，不可假设。\n\n2. **处理 AGENTS.md**：\n   - 新项目：\n     1. 通过提问澄清以下要点（已从描述中获取的可跳过）：项目目标与核心功能、技术栈与版本、代码规范与工具链（lint/formatter/测试）、目录结构偏好。\n     2. 生成高质量 ${code('AGENTS.md')}（须满足下方质量标准，不满足则重新优化直至满足）。\n     3. 继续执行 ${code(c.cmd('plan'))} 创建初始计划。\n   - 旧项目：\n     1. 若不存在 ${code('AGENTS.md')}：通过提问与代码阅读收集信息后生成。\n     2. 若已存在 ${code('AGENTS.md')}：按质量标准评估，不足时增补优化。\n     3. 默认不创建计划（除非用户明确要求）。\n\n3. **输出反馈**：向用户报告项目类型判定结果、AGENTS.md 处理结果、是否需要后续 ${code(c.cmd('plan'))}。\n\n## 高质量 AGENTS.md 标准\n\n- [ ] 常用命令与约束前置，降低代理执行歧义。\n- [ ] 明确列出目录结构（至少到第二层）。\n- [ ] 明确标注技术栈及版本。\n- [ ] 明确代码风格约束（命名规范、格式化工具、lint 配置）。\n- [ ] 内容精简，无冗余段落或模板化填充。\n- [ ] 大型单体仓库按子包拆分维护本地 ${code('AGENTS.md')}。\n\n${renderNextSteps(c, [\n  { command: 'plan', description: '创建新计划' }\n])}`\n}\n"],"mappings":"uFAEA,SAAgB,EAAW,EAA4B,CACrD,MAAO,GAAG,EAAE,YAAY,qCAAqC,CAAC;IAC5D,EAAE,OAAO,OAAO,CAAC;;EAEnB,EAAe,EAAG,OAAQ,0CAA0C,EAAK,YAAY,CAAC,YAAY,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC,UAAU,CAAC;;;;;;;;;;;;;;gBAcnH,EAAK,YAAY,CAAC;eACnB,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;;eAEpB,EAAK,YAAY,CAAC;eAClB,EAAK,YAAY,CAAC;;;kDAGiB,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;;;;;;;;;wBAS9C,EAAK,YAAY,CAAC;;EAExC,EAAgB,EAAG,CACnB,CAAE,QAAS,OAAQ,YAAa,QAAS,CAC1C,CAAC"}

package/dist/domain/workflow-templates/patch.js

@@ -1,41 +0,0 @@
-import{code as e,fence as t,renderNextSteps as n,renderPreamble as r}from"../workflow-context.js";function i(i){return`${i.frontmatter(`基于当前已执行计划创建补丁并回写历史记录`)}\
-# ${i.invoke(`patch`)} {描述}
-
-${r(i,`patch`,`基于当前已执行计划创建增量补丁，修复问题或追加变更，生成 ${e(`patch-{number}.md`)} 并回写计划的影响范围与历史记录。`)}
-
-## 前置规则
-
-- 描述为空 → 拒绝执行。
-- 当前计划不存在 → 拒绝执行，提示先运行 ${e(i.cmd(`plan`))}。
-- 当前计划状态为 ${e(`未执行`)} → 拒绝执行，提示先运行 ${e(i.cmd(`implement`))}。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 补丁不改变计划状态，完成后保持 ${e(`已执行`)}。
-
-## 执行步骤
-
-1. 阅读 ${e(`plan.md`)} 与已有 ${e(`patch-{number}.md`)}，了解上下文与历史补丁，避免重复修复。
-2. 根据描述执行补丁所需的代码变更。
-3. 完成必要验证（测试、类型检查等）。
-4. 创建 ${e(`patch-{number}.md`)}（编号：扫描当前计划目录已有补丁，取 max+1），遵循下方模板。
-5. 回写 ${e(`plan.md`)}：
-   - ${e(`## 历史补丁`)}：追加 ${e(`- patch-{number}: {补丁名称}`)}，按编号去重。
-   - ${e(`## 影响范围`)}：合并本次变更路径，按路径去重。
-
-## patch.md 标准模板
-
-${t}markdown
-# {补丁名称}
-
-## 补丁内容
-
-{修改了什么、为什么修改}
-
-## 影响范围
-
-- 新增文件: ${e(`/path/to/file`)}
-- 修改文件: ${e(`/path/to/file`)}
-- 删除文件: ${e(`/path/to/file`)}
-${t}
-
-${n(i,[{command:`done`,description:`归档当前计划`},{command:`patch`,description:`继续补丁`}])}`}export{i as renderPatch};
-//# sourceMappingURL=patch.js.map

package/dist/domain/workflow-templates/patch.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"patch.js","names":[],"sources":["../../../src/domain/workflow-templates/patch.ts"],"sourcesContent":["import { code, fence, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'\n\nexport function renderPatch(c: WorkflowContext): string {\n  return `${c.frontmatter('基于当前已执行计划创建补丁并回写历史记录')}\\\n# ${c.invoke('patch')} {描述}\n\n${renderPreamble(c, 'patch', `基于当前已执行计划创建增量补丁，修复问题或追加变更，生成 ${code('patch-{number}.md')} 并回写计划的影响范围与历史记录。`)}\n\n## 前置规则\n\n- 描述为空 → 拒绝执行。\n- 当前计划不存在 → 拒绝执行，提示先运行 ${code(c.cmd('plan'))}。\n- 当前计划状态为 ${code('未执行')} → 拒绝执行，提示先运行 ${code(c.cmd('implement'))}。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 补丁不改变计划状态，完成后保持 ${code('已执行')}。\n\n## 执行步骤\n\n1. 阅读 ${code('plan.md')} 与已有 ${code('patch-{number}.md')}，了解上下文与历史补丁，避免重复修复。\n2. 根据描述执行补丁所需的代码变更。\n3. 完成必要验证（测试、类型检查等）。\n4. 创建 ${code('patch-{number}.md')}（编号：扫描当前计划目录已有补丁，取 max+1），遵循下方模板。\n5. 回写 ${code('plan.md')}：\n   - ${code('## 历史补丁')}：追加 ${code('- patch-{number}: {补丁名称}')}，按编号去重。\n   - ${code('## 影响范围')}：合并本次变更路径，按路径去重。\n\n## patch.md 标准模板\n\n${fence}markdown\n# {补丁名称}\n\n## 补丁内容\n\n{修改了什么、为什么修改}\n\n## 影响范围\n\n- 新增文件: ${code('/path/to/file')}\n- 修改文件: ${code('/path/to/file')}\n- 删除文件: ${code('/path/to/file')}\n${fence}\n\n${renderNextSteps(c, [\n  { command: 'done', description: '归档当前计划' },\n  { command: 'patch', description: '继续补丁' }\n])}`\n}\n"],"mappings":"kGAEA,SAAgB,EAAY,EAA4B,CACtD,MAAO,GAAG,EAAE,YAAY,uBAAuB,CAAC;IAC9C,EAAE,OAAO,QAAQ,CAAC;;EAEpB,EAAe,EAAG,QAAS,gCAAgC,EAAK,oBAAoB,CAAC,mBAAmB,CAAC;;;;;yBAKlF,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;YACjC,EAAK,MAAM,CAAC,gBAAgB,EAAK,EAAE,IAAI,YAAY,CAAC,CAAC;;oBAE7C,EAAK,MAAM,CAAC;;;;QAIxB,EAAK,UAAU,CAAC,OAAO,EAAK,oBAAoB,CAAC;;;QAGjD,EAAK,oBAAoB,CAAC;QAC1B,EAAK,UAAU,CAAC;OACjB,EAAK,UAAU,CAAC,MAAM,EAAK,2BAA2B,CAAC;OACvD,EAAK,UAAU,CAAC;;;;EAIrB,EAAM;;;;;;;;;UASE,EAAK,gBAAgB,CAAC;UACtB,EAAK,gBAAgB,CAAC;UACtB,EAAK,gBAAgB,CAAC;EAC9B,EAAM;;EAEN,EAAgB,EAAG,CACnB,CAAE,QAAS,OAAQ,YAAa,SAAU,CAC1C,CAAE,QAAS,QAAS,YAAa,OAAQ,CAC1C,CAAC"}

package/dist/domain/workflow-templates/plan.js

@@ -1,58 +0,0 @@
-import{code as e,fence as t,renderNextSteps as n,renderPreamble as r}from"../workflow-context.js";function i(i){return`${i.frontmatter(`创建新计划并维护单当前计划 + preparing 队列结构`)}\
-# ${i.invoke(`plan`)} {描述}
-
-${r(i,`plan`,`创建新的执行计划，写入 ${e(`.agent-context/plan-{number}/plan.md`)}。按复杂度可拆分为多个计划，维护「单当前计划 + preparing 队列」结构。`)}
-
-## 前置规则
-
-- 描述为空 → 拒绝执行，提示必须附带描述。
-- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 ${e(i.cmd(`done`))}。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 编号：扫描 ${e(`.agent-context/{,preparing/,done/}`)} 全部 ${e(`plan-N`)}，取 max(N)+1，不复用。
-
-## 执行步骤
-
-1. **需求澄清**（存在以下任一歧义时必须向用户提问，否则直接跳到步骤 2）：
-   - 范围边界不清：无法判定影响哪些文件或模块。
-   - 存在显著不同的技术路径需用户决策。
-   - 验收标准不明确：无法判断何时算"完成"。
-2. 按复杂度决定单计划或多计划拆分。
-3. 多计划拆分时：最小编号进入 ${e(`.agent-context/`)} 作为当前计划，其余进入 ${e(`.agent-context/preparing/`)}。单计划直接创建到 ${e(`.agent-context/plan-{number}`)}。
-4. 每个计划创建 ${e(`plan.md`)}，遵循下方标准模板。
-5. **计划自检**（不通过则修改后重新检查）：
-   - 每个步骤可独立执行且有明确完成标准。
-   - 不存在过度拆分（过于琐碎）或拆分不足（单步骤过于复杂）。
-   - 影响范围可预估。
-
-## plan.md 标准模板
-
-${t}markdown
-# {计划名称}
-
-> 状态: 未执行
-
-## 目标
-
-{明确的目标描述}
-
-## 内容
-
-{详细的实施步骤和内容}
-
-## 影响范围
-
-- 新增文件: \`/path/to/file\`
-- 修改文件: \`/path/to/file\`
-- 删除文件: \`/path/to/file\`
-
-## 历史补丁
-
-- patch-1: {补丁名称}
-${t}
-
-- 状态行唯一，仅允许 ${e(`未执行`)} 或 ${e(`已执行`)}。
-- ${e(`## 目标`)} 与 ${e(`## 内容`)} 不可为空。
-- ${e(`## 影响范围`)} 与 ${e(`## 历史补丁`)} 创建时留空，分别由 ${e(i.cmd(`implement`))} 和 ${e(i.cmd(`patch`))} 写入。
-
-${n(i,[{command:`implement`,description:`实施当前计划`},{command:`replan`,description:`调整计划`}])}`}export{i as renderPlan};
-//# sourceMappingURL=plan.js.map

package/dist/domain/workflow-templates/plan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plan.js","names":[],"sources":["../../../src/domain/workflow-templates/plan.ts"],"sourcesContent":["import {\n  code,\n  fence,\n  renderNextSteps,\n  renderPreamble,\n  type WorkflowContext\n} from '../workflow-context'\n\nexport function renderPlan(c: WorkflowContext): string {\n  return `${c.frontmatter('创建新计划并维护单当前计划 + preparing 队列结构')}\\\n# ${c.invoke('plan')} {描述}\n\n${renderPreamble(c, 'plan', `创建新的执行计划，写入 ${code('.agent-context/plan-{number}/plan.md')}。按复杂度可拆分为多个计划，维护「单当前计划 + preparing 队列」结构。`)}\n\n## 前置规则\n\n- 描述为空 → 拒绝执行，提示必须附带描述。\n- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 ${code(c.cmd('done'))}。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 编号：扫描 ${code('.agent-context/{,preparing/,done/}')} 全部 ${code('plan-N')}，取 max(N)+1，不复用。\n\n## 执行步骤\n\n1. **需求澄清**（存在以下任一歧义时必须向用户提问，否则直接跳到步骤 2）：\n   - 范围边界不清：无法判定影响哪些文件或模块。\n   - 存在显著不同的技术路径需用户决策。\n   - 验收标准不明确：无法判断何时算\"完成\"。\n2. 按复杂度决定单计划或多计划拆分。\n3. 多计划拆分时：最小编号进入 ${code('.agent-context/')} 作为当前计划，其余进入 ${code('.agent-context/preparing/')}。单计划直接创建到 ${code('.agent-context/plan-{number}')}。\n4. 每个计划创建 ${code('plan.md')}，遵循下方标准模板。\n5. **计划自检**（不通过则修改后重新检查）：\n   - 每个步骤可独立执行且有明确完成标准。\n   - 不存在过度拆分（过于琐碎）或拆分不足（单步骤过于复杂）。\n   - 影响范围可预估。\n\n## plan.md 标准模板\n\n${fence}markdown\n# {计划名称}\n\n> 状态: 未执行\n\n## 目标\n\n{明确的目标描述}\n\n## 内容\n\n{详细的实施步骤和内容}\n\n## 影响范围\n\n- 新增文件: \\`/path/to/file\\`\n- 修改文件: \\`/path/to/file\\`\n- 删除文件: \\`/path/to/file\\`\n\n## 历史补丁\n\n- patch-1: {补丁名称}\n${fence}\n\n- 状态行唯一，仅允许 ${code('未执行')} 或 ${code('已执行')}。\n- ${code('## 目标')} 与 ${code('## 内容')} 不可为空。\n- ${code('## 影响范围')} 与 ${code('## 历史补丁')} 创建时留空，分别由 ${code(c.cmd('implement'))} 和 ${code(c.cmd('patch'))} 写入。\n\n${renderNextSteps(c, [\n  { command: 'implement', description: '实施当前计划' },\n  { command: 'replan', description: '调整计划' }\n])}`\n}\n"],"mappings":"kGAQA,SAAgB,EAAW,EAA4B,CACrD,MAAO,GAAG,EAAE,YAAY,iCAAiC,CAAC;IACxD,EAAE,OAAO,OAAO,CAAC;;EAEnB,EAAe,EAAG,OAAQ,eAAe,EAAK,uCAAuC,CAAC,2CAA2C,CAAC;;;;;+BAKrG,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;;UAEzC,EAAK,qCAAqC,CAAC,MAAM,EAAK,SAAS,CAAC;;;;;;;;;mBASvD,EAAK,kBAAkB,CAAC,eAAe,EAAK,4BAA4B,CAAC,YAAY,EAAK,+BAA+B,CAAC;YACjI,EAAK,UAAU,CAAC;;;;;;;;EAQ1B,EAAM;;;;;;;;;;;;;;;;;;;;;;EAsBN,EAAM;;cAEM,EAAK,MAAM,CAAC,KAAK,EAAK,MAAM,CAAC;IACvC,EAAK,QAAQ,CAAC,KAAK,EAAK,QAAQ,CAAC;IACjC,EAAK,UAAU,CAAC,KAAK,EAAK,UAAU,CAAC,aAAa,EAAK,EAAE,IAAI,YAAY,CAAC,CAAC,KAAK,EAAK,EAAE,IAAI,QAAQ,CAAC,CAAC;;EAEvG,EAAgB,EAAG,CACnB,CAAE,QAAS,YAAa,YAAa,SAAU,CAC/C,CAAE,QAAS,SAAU,YAAa,OAAQ,CAC3C,CAAC"}

package/dist/domain/workflow-templates/replan.js

@@ -1,31 +0,0 @@
-import{code as e,renderNextSteps as t,renderPreamble as n}from"../workflow-context.js";function r(r){return`${r.frontmatter(`重规划未实施计划，保持单当前计划结构不变`)}\
-# ${r.invoke(`replan`)} {描述}
-
-${n(r,`replan`,`重新规划已有的未实施计划（${e(`preparing/`)} 队列或未执行的当前计划），保持单当前计划结构不变。`)}
-
-## 前置规则
-
-- 描述为空 → 拒绝执行。
-- 无未实施计划 → 拒绝执行，提示使用 ${e(r.cmd(`plan`))} 创建。
-- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
-- 目标计划编号不存在 → 拒绝执行，列出可选编号。
-- 目标计划已执行 → 拒绝执行，提示使用 ${e(r.cmd(`patch`))} 修补。
-- 重规划后违反单当前计划约束 → 回滚并报错。
-
-## 作用域规则
-
-- 默认作用域：${e(`.agent-context/preparing/`)} 中全部未实施计划。
-- 可通过描述指定仅重规划部分计划（如"重规划 plan-3 和 plan-5"）。
-- 当前计划为 ${e(`已执行`)} → 禁止重写，仅允许重规划 ${e(`preparing/`)} 队列。
-- 当前计划为 ${e(`未执行`)} 且用户明确要求 → 可纳入重规划范围。
-
-## 执行步骤
-
-1. 解析描述，确定重规划目标范围。
-2. 读取目标计划 ${e(`plan.md`)}，理解现有意图。
-3. 生成新的拆分方案，保持"单当前计划 + 若干 preparing 计划"结构。
-4. 新增计划编号：全局 max(N)+1 递增分配；未改动计划保持原编号。
-5. 更新目录结构，确保每个新计划的 ${e(`plan.md`)} 遵循标准模板。
-
-${t(r,[{command:`implement`,description:`实施当前计划`}])}`}export{r as renderReplan};
-//# sourceMappingURL=replan.js.map

package/dist/domain/workflow-templates/replan.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"replan.js","names":[],"sources":["../../../src/domain/workflow-templates/replan.ts"],"sourcesContent":["import { code, renderNextSteps, renderPreamble, type WorkflowContext } from '../workflow-context'\n\nexport function renderReplan(c: WorkflowContext): string {\n  return `${c.frontmatter('重规划未实施计划，保持单当前计划结构不变')}\\\n# ${c.invoke('replan')} {描述}\n\n${renderPreamble(c, 'replan', `重新规划已有的未实施计划（${code('preparing/')} 队列或未执行的当前计划），保持单当前计划结构不变。`)}\n\n## 前置规则\n\n- 描述为空 → 拒绝执行。\n- 无未实施计划 → 拒绝执行，提示使用 ${code(c.cmd('plan'))} 创建。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 目标计划编号不存在 → 拒绝执行，列出可选编号。\n- 目标计划已执行 → 拒绝执行，提示使用 ${code(c.cmd('patch'))} 修补。\n- 重规划后违反单当前计划约束 → 回滚并报错。\n\n## 作用域规则\n\n- 默认作用域：${code('.agent-context/preparing/')} 中全部未实施计划。\n- 可通过描述指定仅重规划部分计划（如\"重规划 plan-3 和 plan-5\"）。\n- 当前计划为 ${code('已执行')} → 禁止重写，仅允许重规划 ${code('preparing/')} 队列。\n- 当前计划为 ${code('未执行')} 且用户明确要求 → 可纳入重规划范围。\n\n## 执行步骤\n\n1. 解析描述，确定重规划目标范围。\n2. 读取目标计划 ${code('plan.md')}，理解现有意图。\n3. 生成新的拆分方案，保持\"单当前计划 + 若干 preparing 计划\"结构。\n4. 新增计划编号：全局 max(N)+1 递增分配；未改动计划保持原编号。\n5. 更新目录结构，确保每个新计划的 ${code('plan.md')} 遵循标准模板。\n\n${renderNextSteps(c, [\n  { command: 'implement', description: '实施当前计划' }\n])}`\n}\n"],"mappings":"uFAEA,SAAgB,EAAa,EAA4B,CACvD,MAAO,GAAG,EAAE,YAAY,uBAAuB,CAAC;IAC9C,EAAE,OAAO,SAAS,CAAC;;EAErB,EAAe,EAAG,SAAU,gBAAgB,EAAK,aAAa,CAAC,4BAA4B,CAAC;;;;;uBAKvE,EAAK,EAAE,IAAI,OAAO,CAAC,CAAC;;;wBAGnB,EAAK,EAAE,IAAI,QAAQ,CAAC,CAAC;;;;;UAKnC,EAAK,4BAA4B,CAAC;;UAElC,EAAK,MAAM,CAAC,iBAAiB,EAAK,aAAa,CAAC;UAChD,EAAK,MAAM,CAAC;;;;;YAKV,EAAK,UAAU,CAAC;;;qBAGP,EAAK,UAAU,CAAC;;EAEnC,EAAgB,EAAG,CACnB,CAAE,QAAS,YAAa,YAAa,SAAU,CAChD,CAAC"}

package/dist/generators/workflow.js

@@ -1,2 +0,0 @@
-import{resolveWorkflowPaths as e}from"../adapters/tool-targets.js";import{renderWorkflowArtifacts as t}from"../domain/workflow-content.js";const n=[`init`,`plan`,`replan`,`implement`,`patch`,`done`];function r(r,i){let a=t(r),o=e(r,i),s=[];for(let e of n)s.push({path:o.commandFile(e),body:a.commandFiles[e]});return s}export{r as renderWorkflowMutations};
-//# sourceMappingURL=workflow.js.map

package/dist/generators/workflow.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"workflow.js","names":[],"sources":["../../src/generators/workflow.ts"],"sourcesContent":["import { resolveWorkflowPaths } from '../adapters/tool-targets'\nimport type { FileMutation, ToolTarget, WorkflowCommandName } from '../domain/types'\nimport { renderWorkflowArtifacts } from '../domain/workflow-content'\n\nconst COMMAND_ORDER: WorkflowCommandName[] = [\n  'init',\n  'plan',\n  'replan',\n  'implement',\n  'patch',\n  'done'\n]\n\nexport function renderWorkflowMutations(target: ToolTarget, cwd: string): FileMutation[] {\n  const artifacts = renderWorkflowArtifacts(target)\n  const paths = resolveWorkflowPaths(target, cwd)\n\n  const mutations: FileMutation[] = []\n\n  for (const command of COMMAND_ORDER) {\n    mutations.push({ path: paths.commandFile(command), body: artifacts.commandFiles[command] })\n  }\n\n  return mutations\n}\n"],"mappings":"2IAIA,MAAM,EAAuC,CAC3C,OACA,OACA,SACA,YACA,QACA,OACD,CAED,SAAgB,EAAwB,EAAoB,EAA6B,CACvF,IAAM,EAAY,EAAwB,EAAO,CAC3C,EAAQ,EAAqB,EAAQ,EAAI,CAEzC,EAA4B,EAAE,CAEpC,IAAK,IAAM,KAAW,EACpB,EAAU,KAAK,CAAE,KAAM,EAAM,YAAY,EAAQ,CAAE,KAAM,EAAU,aAAa,GAAU,CAAC,CAG7F,OAAO"}

package/dist/runtime/execute.js

@@ -1,2 +0,0 @@
-import{resolveToolTargets as e}from"../adapters/tool-targets.js";import{renderWorkflowMutations as t}from"../generators/workflow.js";import{applyManagedMutations as n}from"../shared/fs.js";async function r(e={}){return a(`setup`,e)}async function i(e={}){return a(`update`,e)}async function a(r,i){let a=i.cwd??process.cwd(),s=e(o(i.tools)).flatMap(e=>t(e,a)),c=i.check??!1;return{...await n(s,c),mode:r,check:c}}function o(e){if(!e||e.length===0)return;let t=[];for(let n of e)t.includes(n)||t.push(n);return t}export{r as runSetup,i as runUpdate};
-//# sourceMappingURL=execute.js.map

package/dist/runtime/execute.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"execute.js","names":[],"sources":["../../src/runtime/execute.ts"],"sourcesContent":["import { resolveToolTargets } from '../adapters/tool-targets'\nimport type { FileMutation, RunOptions, RunResult, ToolId } from '../domain/types'\nimport { renderWorkflowMutations } from '../generators/workflow'\nimport { applyManagedMutations } from '../shared/fs'\n\nexport async function runSetup(options: RunOptions = {}): Promise<RunResult> {\n  return runInMode('setup', options)\n}\n\nexport async function runUpdate(options: RunOptions = {}): Promise<RunResult> {\n  return runInMode('update', options)\n}\n\nasync function runInMode(mode: 'setup' | 'update', options: RunOptions): Promise<RunResult> {\n  const cwd = options.cwd ?? process.cwd()\n  const toolIds = normalizeTools(options.tools)\n  const targets = resolveToolTargets(toolIds)\n\n  const mutations: FileMutation[] = targets.flatMap(target => renderWorkflowMutations(target, cwd))\n\n  const check = options.check ?? false\n  const result = await applyManagedMutations(mutations, check)\n\n  return {\n    ...result,\n    mode,\n    check\n  }\n}\n\nfunction normalizeTools(tools?: ToolId[]): ToolId[] | undefined {\n  if (!tools || tools.length === 0) {\n    return undefined\n  }\n\n  const uniqueTools: ToolId[] = []\n\n  for (const tool of tools) {\n    if (!uniqueTools.includes(tool)) {\n      uniqueTools.push(tool)\n    }\n  }\n\n  return uniqueTools\n}\n"],"mappings":"6LAKA,eAAsB,EAAS,EAAsB,EAAE,CAAsB,CAC3E,OAAO,EAAU,QAAS,EAAQ,CAGpC,eAAsB,EAAU,EAAsB,EAAE,CAAsB,CAC5E,OAAO,EAAU,SAAU,EAAQ,CAGrC,eAAe,EAAU,EAA0B,EAAyC,CAC1F,IAAM,EAAM,EAAQ,KAAO,QAAQ,KAAK,CAIlC,EAFU,EADA,EAAe,EAAQ,MAAM,CACF,CAED,QAAQ,GAAU,EAAwB,EAAQ,EAAI,CAAC,CAE3F,EAAQ,EAAQ,OAAS,GAG/B,MAAO,CACL,GAHa,MAAM,EAAsB,EAAW,EAAM,CAI1D,OACA,QACD,CAGH,SAAS,EAAe,EAAwC,CAC9D,GAAI,CAAC,GAAS,EAAM,SAAW,EAC7B,OAGF,IAAM,EAAwB,EAAE,CAEhC,IAAK,IAAM,KAAQ,EACZ,EAAY,SAAS,EAAK,EAC7B,EAAY,KAAK,EAAK,CAI1B,OAAO"}

package/dist/shared/fs.js

@@ -1,3 +0,0 @@
-import{existsSync as e}from"node:fs";import{dirname as t}from"node:path";import{mkdir as n,readFile as r,writeFile as i}from"node:fs/promises";async function a(r,a){let s={created:[],updated:[],unchanged:[],changed:[]};for(let c of r){let r=e(c.path),l=await o(c,r);if(!l.changed){s.unchanged.push(c.path);continue}a||(await n(t(c.path),{recursive:!0}),await i(c.path,l.content,`utf-8`)),s.changed.push(c.path),r?s.updated.push(c.path):s.created.push(c.path)}return s}async function o(e,t){let n=s(e.body);return t?{content:n,changed:await r(e.path,`utf-8`)!==n}:{content:n,changed:!0}}function s(e){return e.endsWith(`
-`)?e:`${e}\n`}export{a as applyManagedMutations};
-//# sourceMappingURL=fs.js.map

package/dist/shared/fs.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"fs.js","names":[],"sources":["../../src/shared/fs.ts"],"sourcesContent":["import { dirname } from 'node:path'\nimport { existsSync } from 'node:fs'\nimport { mkdir, readFile, writeFile } from 'node:fs/promises'\n\nimport type { ApplyMutationResult, FileMutation } from '../domain/types'\n\nexport async function applyManagedMutations(\n  mutations: FileMutation[],\n  check: boolean\n): Promise<ApplyMutationResult> {\n  const result: ApplyMutationResult = {\n    created: [],\n    updated: [],\n    unchanged: [],\n    changed: []\n  }\n\n  for (const mutation of mutations) {\n    const fileExists = existsSync(mutation.path)\n    const nextContent = await resolveNextContent(mutation, fileExists)\n\n    if (!nextContent.changed) {\n      result.unchanged.push(mutation.path)\n      continue\n    }\n\n    if (!check) {\n      await mkdir(dirname(mutation.path), { recursive: true })\n      await writeFile(mutation.path, nextContent.content, 'utf-8')\n    }\n\n    result.changed.push(mutation.path)\n\n    if (fileExists) {\n      result.updated.push(mutation.path)\n    } else {\n      result.created.push(mutation.path)\n    }\n  }\n\n  return result\n}\n\nasync function resolveNextContent(\n  mutation: FileMutation,\n  fileExists: boolean\n): Promise<{ content: string; changed: boolean }> {\n  const nextContent = normalizeTrailingNewline(mutation.body)\n\n  if (!fileExists) {\n    return {\n      content: nextContent,\n      changed: true\n    }\n  }\n\n  const currentContent = await readFile(mutation.path, 'utf-8')\n  return {\n    content: nextContent,\n    changed: currentContent !== nextContent\n  }\n}\n\nfunction normalizeTrailingNewline(content: string): string {\n  return content.endsWith('\\n') ? content : `${content}\\n`\n}\n"],"mappings":"+IAMA,eAAsB,EACpB,EACA,EAC8B,CAC9B,IAAM,EAA8B,CAClC,QAAS,EAAE,CACX,QAAS,EAAE,CACX,UAAW,EAAE,CACb,QAAS,EAAE,CACZ,CAED,IAAK,IAAM,KAAY,EAAW,CAChC,IAAM,EAAa,EAAW,EAAS,KAAK,CACtC,EAAc,MAAM,EAAmB,EAAU,EAAW,CAElE,GAAI,CAAC,EAAY,QAAS,CACxB,EAAO,UAAU,KAAK,EAAS,KAAK,CACpC,SAGG,IACH,MAAM,EAAM,EAAQ,EAAS,KAAK,CAAE,CAAE,UAAW,GAAM,CAAC,CACxD,MAAM,EAAU,EAAS,KAAM,EAAY,QAAS,QAAQ,EAG9D,EAAO,QAAQ,KAAK,EAAS,KAAK,CAE9B,EACF,EAAO,QAAQ,KAAK,EAAS,KAAK,CAElC,EAAO,QAAQ,KAAK,EAAS,KAAK,CAItC,OAAO,EAGT,eAAe,EACb,EACA,EACgD,CAChD,IAAM,EAAc,EAAyB,EAAS,KAAK,CAU3D,OARK,EAQE,CACL,QAAS,EACT,QAHqB,MAAM,EAAS,EAAS,KAAM,QAAQ,GAG/B,EAC7B,CAVQ,CACL,QAAS,EACT,QAAS,GACV,CAUL,SAAS,EAAyB,EAAyB,CACzD,OAAO,EAAQ,SAAS;EAAK,CAAG,EAAU,GAAG,EAAQ"}