@cat-kit/agent-context 1.0.7 → 1.1.1

package/README.md

@@ -1,12 +1,19 @@
 # Agent Context
 
-`@cat-kit/agent-context` 为主流 AI 编程助手生成统一的 `ac` 前缀工作流命令，让你用一套固定流程驱动 AI 完成从需求到交付的全过程。
+`@cat-kit/agent-context` 为主流 AI 编程助手安装统一的 `agent-context` Skill，让同一套计划生命周期协议在不同工具里保持一致。
 
 ## 它解决什么问题
 
-不同 AI 编程工具（Claude、Codex、Cursor、Copilot……）各有自己的命令格式和目录约定。当你同时使用多个工具时，需要为每个工具分别编写和维护工作流命令，内容重复且容易不一致。
+旧版 AI 工具通常依赖命令文件或 workflow 目录来驱动任务流程，但现在主流产品都在转向 Skills。  
+如果你同时使用 Claude、Codex、Cursor、Antigravity、GitHub Copilot，就需要为不同工具分别维护同一套计划规则，内容容易漂移。
 
-`agent-context` 只需一条命令，就能为你选择的所有工具生成格式正确、内容统一的工作流命令文件。
+`agent-context` v2 只维护一个核心 Skill，负责统一以下生命周期：
+
+```text
+init -> plan -> replan -> implement -> patch -> done
+```
+
+Skill 内部会约束 `.agent-context/` 目录、计划编号、`plan.md` 模板、实施验证和归档规则，用户不再需要依赖 `/ac-init` 这类命令触发。
 
 ## 安装
 
@@ -21,91 +28,81 @@ npm install -g @cat-kit/agent-context
 在项目根目录执行：
 
 ```bash
-agent-context setup
-```
-
-交互式选择你使用的 AI 工具后，工具会自动在项目中生成对应的命令文件。之后你就可以在 AI 助手中直接调用这些命令了。
-
-## 工作流
-
-Agent Context 定义了 6 个命令，覆盖一个计划从创建到归档的完整生命周期：
-
-```
-init → plan → replan → implement → patch → done
+agent-context install
 ```
 
-| 命令        | 作用             | 典型场景                           |
-| ----------- | ---------------- | ---------------------------------- |
-| `init`      | 初始化项目上下文 | 当你第一次在这个项目使用时         |
-| `plan`      | 创建新计划       | 开始一个新需求或任务               |
-| `replan`    | 重新规划         | 计划不合理或需求变更时调整         |
-| `implement` | 实施计划         | 让 AI 按计划逐步编码               |
-| `patch`     | 补丁修复         | 实施完成后发现需要小幅修改         |
-| `done`      | 归档计划         | 任务彻底完成，归档并进入下一个计划 |
+交互式选择目标工具后，CLI 会在对应的 Skills 目录下安装统一的 `agent-context` Skill。
 
-### 典型工作流示例
+安装完成后，你可以直接向 AI 助手表达自然语言意图，例如：
 
-**场景：为项目添加一个新功能**
+- “初始化这个项目的 agent context”
+- “为这个需求出一个计划”
+- “重做当前计划”
+- “按当前计划开始实现”
+- “给当前计划补一个 patch”
+- “当前计划已经真正完成，归档它”
 
-```
-1. /ac-init          ← 首次使用，初始化项目上下文
-2. /ac-plan          ← 描述需求，AI 生成实施计划
-3. /ac-implement     ← AI 按计划编码实施
-4. /ac-patch         ← 修复实施中遗漏的细节
-5. /ac-done          ← 确认完成，归档计划
-```
+## 支持的工具
 
-**场景：计划不满意，需要调整**
+| 工具 | Skill 目录 |
+| --- | --- |
+| Claude | `.claude/skills/agent-context/` |
+| Codex | `.codex/skills/agent-context/` |
+| Cursor | `.cursor/skills/agent-context/` |
+| Antigravity | `.agent/skills/agent-context/` |
+| GitHub Copilot | `.github/skills/agent-context/` |
 
-```
-1. /ac-plan          ← 创建计划
-2. /ac-replan        ← 描述调整方向，AI 重新规划
-3. /ac-implement     ← 按新计划实施
-4. /ac-done          ← 归档
-```
+## 生成产物
 
-## 支持的工具
+`agent-context` 会按工具生成对应官方支持的 Skill 产物：
 
-| 工具           | 命令文件目录        | 调用方式示例 |
-| -------------- | ------------------- | ------------ |
-| Claude         | `.claude/commands/` | `/ac:init`   |
-| Codex          | `.codex/prompts/`   | `/ac-init`   |
-| Cursor         | `.cursor/commands/` | `/ac-init`   |
-| Antigravity    | `.agent/workflows/` | `/ac-init`   |
-| GitHub Copilot | `.github/prompts/`  | `#ac-init`   |
+| 工具 | 产物 |
+| --- | --- |
+| Claude | `SKILL.md`，包含 `name`、`description`、`argument-hint` frontmatter |
+| Codex | `SKILL.md` + `agents/openai.yaml` |
+| Cursor | `SKILL.md` |
+| Antigravity | `SKILL.md` |
+| GitHub Copilot | `SKILL.md`，包含 `name`、`description`、`license` frontmatter |
 
 ## 命令参考
 
-### `agent-context setup`
+### `agent-context install`
 
-初始化工作流命令。交互式选择目标工具后，在项目中生成对应的命令文件。
+安装 `agent-context` Skill。
 
 ```bash
-# 交互式
-agent-context setup
+# 交互式选择工具
+agent-context install
 
-# 直接指定工具，跳过选择
-agent-context setup --tools claude,cursor,copilot
+# 指定工具
+agent-context install --tools claude,codex,cursor
+
+# 仅检查将产生哪些变更
+agent-context install --check --tools copilot
 ```
 
-### `agent-context update`
+### `agent-context sync`
 
-更新已有的工作流命令文件（仅更新已安装的工具，不新增）。适用于升级 `@cat-kit/agent-context` 版本后同步最新模板。
+同步已经安装的 `agent-context` Skill。适用于升级 `@cat-kit/agent-context` 版本后更新 Skill 内容。
 
 ```bash
-agent-context update
+# 同步当前已安装工具
+agent-context sync
+
+# 同步指定工具
+agent-context sync --tools claude,cursor
 
-# 仅检查是否有待更新内容，不实际写入
-agent-context update --check
+# 仅检查是否有待同步内容
+agent-context sync --check
 ```
 
 ### 通用选项
 
-| 选项              | 说明                   |
-| ----------------- | ---------------------- |
+| 选项 | 说明 |
+| --- | --- |
 | `--tools <tools>` | 指定目标工具，逗号分隔 |
-| `--yes`           | 非交互模式             |
-| `--check`         | 仅检查，不写入文件     |
+| `--check` | 仅检查，不写入文件 |
+| `--yes` | 仅 `install` 支持；非交互模式下优先复用已安装工具，否则安装全部工具 |
 
 ## License
 

package/dist/cli.js

@@ -1,3 +1,3 @@
 #!/usr/bin/env node
-import{setupCommand as e}from"./commands/setup.js";import{updateCommand as t}from"./commands/update.js";import{readFileSync as n}from"node:fs";import{Command as r}from"commander";const i=JSON.parse(n(new URL(`../package.json`,import.meta.url),`utf8`)),a=typeof i.version==`string`?i.version:`0.0.0`,o=new r;o.name(`agent-context`).description(`Agent Context 工作流生成工具`).version(a),o.command(`setup`).description(`初始化工作流命令`).option(`--tools <tools>`,`指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot`).option(`--yes`,`非交互模式预留参数（当前版本无需确认）`).option(`--check`,`仅检查是否存在待更新内容，不写入文件`).action(e),o.command(`update`).description(`更新工作流命令`).option(`--tools <tools>`,`指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot`).option(`--yes`,`非交互模式预留参数（当前版本无需确认）`).option(`--check`,`仅检查是否存在待更新内容，不写入文件`).action(t),o.parseAsync().catch(e=>{let t=e instanceof Error?e.message:String(e);console.error(`\n❌ ${t}`),process.exitCode=1});export{};
+import{doneCommand as e}from"./commands/done.js";import{installCommand as t}from"./commands/install.js";import{statusCommand as n}from"./commands/status.js";import{syncCommand as r}from"./commands/sync.js";import{validateCommand as i}from"./commands/validate.js";import{readFileSync as a}from"node:fs";import{Command as o}from"commander";const s=JSON.parse(a(new URL(`../package.json`,import.meta.url),`utf8`)),c=typeof s.version==`string`?s.version:`0.0.0`,l=new o;l.name(`agent-context`).description(`Agent Context Skills 安装工具`).version(c),l.command(`install`).description(`安装 ac-workflow Skill`).option(`--tools <tools>`,`指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot`).option(`--yes`,`非交互模式：优先复用已安装工具，否则安装全部工具`).option(`--check`,`仅检查是否存在待更新内容，不写入文件`).action(t),l.command(`sync`).description(`同步已安装的 ac-workflow Skill`).option(`--tools <tools>`,`指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot`).option(`--check`,`仅检查是否存在待更新内容，不写入文件`).action(r),l.command(`validate`).description(`校验 .agent-context 目录结构`).action(i),l.command(`status`).description(`查看当前 agent-context 状态`).action(n),l.command(`done`).description(`归档当前已执行计划`).option(`--yes`,`跳过确认，直接归档`).action(e),l.parseAsync().catch(e=>{let t=e instanceof Error?e.message:String(e);console.error(`\n❌ ${t}`),process.exitCode=1});export{};
 //# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -1 +1 @@
-{"version":3,"file":"cli.js","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { readFileSync } from 'node:fs'\nimport { Command } from 'commander'\n\nimport { setupCommand } from './commands/setup'\nimport { updateCommand } from './commands/update'\n\nconst packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8')) as {\n  version?: string\n}\nconst packageVersion = typeof packageJson.version === 'string' ? packageJson.version : '0.0.0'\n\nconst program = new Command()\n\nprogram.name('agent-context').description('Agent Context 工作流生成工具').version(packageVersion)\n\nprogram\n  .command('setup')\n  .description('初始化工作流命令')\n  .option('--tools <tools>', '指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot')\n  .option('--yes', '非交互模式预留参数（当前版本无需确认）')\n  .option('--check', '仅检查是否存在待更新内容，不写入文件')\n  .action(setupCommand)\n\nprogram\n  .command('update')\n  .description('更新工作流命令')\n  .option('--tools <tools>', '指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot')\n  .option('--yes', '非交互模式预留参数（当前版本无需确认）')\n  .option('--check', '仅检查是否存在待更新内容，不写入文件')\n  .action(updateCommand)\n\nprogram.parseAsync().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : String(error)\n  console.error(`\\n❌ ${message}`) // eslint-disable-line no-console\n  process.exitCode = 1\n})\n"],"mappings":";mLAQA,MAAM,EAAc,KAAK,MAAM,EAAa,IAAI,IAAI,kBAAmB,OAAO,KAAK,IAAI,CAAE,OAAO,CAAC,CAG3F,EAAiB,OAAO,EAAY,SAAY,SAAW,EAAY,QAAU,QAEjF,EAAU,IAAI,EAEpB,EAAQ,KAAK,gBAAgB,CAAC,YAAY,wBAAwB,CAAC,QAAQ,EAAe,CAE1F,EACG,QAAQ,QAAQ,CAChB,YAAY,WAAW,CACvB,OAAO,kBAAmB,sDAAsD,CAChF,OAAO,QAAS,sBAAsB,CACtC,OAAO,UAAW,qBAAqB,CACvC,OAAO,EAAa,CAEvB,EACG,QAAQ,SAAS,CACjB,YAAY,UAAU,CACtB,OAAO,kBAAmB,sDAAsD,CAChF,OAAO,QAAS,sBAAsB,CACtC,OAAO,UAAW,qBAAqB,CACvC,OAAO,EAAc,CAExB,EAAQ,YAAY,CAAC,MAAO,GAAmB,CAC7C,IAAM,EAAU,aAAiB,MAAQ,EAAM,QAAU,OAAO,EAAM,CACtE,QAAQ,MAAM,OAAO,IAAU,CAC/B,QAAQ,SAAW,GACnB"}
+{"version":3,"file":"cli.js","names":[],"sources":["../src/cli.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { readFileSync } from 'node:fs'\n\nimport { Command } from 'commander'\n\nimport { doneCommand } from './commands/done.js'\nimport { installCommand } from './commands/install.js'\nimport { statusCommand } from './commands/status.js'\nimport { syncCommand } from './commands/sync.js'\nimport { validateCommand } from './commands/validate.js'\n\nconst packageJson = JSON.parse(\n  readFileSync(new URL('../package.json', import.meta.url), 'utf8')\n) as { version?: string }\nconst packageVersion = typeof packageJson.version === 'string' ? packageJson.version : '0.0.0'\n\nconst program = new Command()\n\nprogram.name('agent-context').description('Agent Context Skills 安装工具').version(packageVersion)\n\nprogram\n  .command('install')\n  .description('安装 ac-workflow Skill')\n  .option('--tools <tools>', '指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot')\n  .option('--yes', '非交互模式：优先复用已安装工具，否则安装全部工具')\n  .option('--check', '仅检查是否存在待更新内容，不写入文件')\n  .action(installCommand)\n\nprogram\n  .command('sync')\n  .description('同步已安装的 ac-workflow Skill')\n  .option('--tools <tools>', '指定目标工具，逗号分隔：claude,codex,cursor,antigravity,copilot')\n  .option('--check', '仅检查是否存在待更新内容，不写入文件')\n  .action(syncCommand)\n\nprogram\n  .command('validate')\n  .description('校验 .agent-context 目录结构')\n  .action(validateCommand)\n\nprogram\n  .command('status')\n  .description('查看当前 agent-context 状态')\n  .action(statusCommand)\n\nprogram\n  .command('done')\n  .description('归档当前已执行计划')\n  .option('--yes', '跳过确认，直接归档')\n  .action(doneCommand)\n\nprogram.parseAsync().catch((error: unknown) => {\n  const message = error instanceof Error ? error.message : String(error)\n  console.error(`\\n❌ ${message}`) // eslint-disable-line no-console\n  process.exitCode = 1\n})\n"],"mappings":";kVAYA,MAAM,EAAc,KAAK,MACvB,EAAa,IAAI,IAAI,kBAAmB,OAAO,KAAK,IAAI,CAAE,OAAO,CAClE,CACK,EAAiB,OAAO,EAAY,SAAY,SAAW,EAAY,QAAU,QAEjF,EAAU,IAAI,EAEpB,EAAQ,KAAK,gBAAgB,CAAC,YAAY,4BAA4B,CAAC,QAAQ,EAAe,CAE9F,EACG,QAAQ,UAAU,CAClB,YAAY,uBAAuB,CACnC,OAAO,kBAAmB,sDAAsD,CAChF,OAAO,QAAS,2BAA2B,CAC3C,OAAO,UAAW,qBAAqB,CACvC,OAAO,EAAe,CAEzB,EACG,QAAQ,OAAO,CACf,YAAY,2BAA2B,CACvC,OAAO,kBAAmB,sDAAsD,CAChF,OAAO,UAAW,qBAAqB,CACvC,OAAO,EAAY,CAEtB,EACG,QAAQ,WAAW,CACnB,YAAY,yBAAyB,CACrC,OAAO,EAAgB,CAE1B,EACG,QAAQ,SAAS,CACjB,YAAY,wBAAwB,CACpC,OAAO,EAAc,CAExB,EACG,QAAQ,OAAO,CACf,YAAY,YAAY,CACxB,OAAO,QAAS,YAAY,CAC5B,OAAO,EAAY,CAEtB,EAAQ,YAAY,CAAC,MAAO,GAAmB,CAC7C,IAAM,EAAU,aAAiB,MAAQ,EAAM,QAAU,OAAO,EAAM,CACtE,QAAQ,MAAM,OAAO,IAAU,CAC/B,QAAQ,SAAW,GACnB"}

package/dist/commands/done.js

@@ -0,0 +1,2 @@
+import{readRawContext as e}from"../context/reader.js";import{validate as t}from"../context/validator.js";import{archive as n}from"../context/archiver.js";import{basename as r}from"node:path";import{confirm as i}from"@inquirer/prompts";async function a(a){let{snapshot:o,currentPlanCount:s}=await e(process.cwd()),c=t(o,s);if(!c.valid){for(let e of c.errors)console.log(`❌ ${e}`);process.exitCode=1;return}if(!o||!o.currentPlan){console.log(`❌ 无当前计划`),process.exitCode=1;return}if(o.currentPlan.status!==`已执行`){console.log(`❌ 当前计划 plan-${o.currentPlan.number} 尚未执行，无法归档。`),process.exitCode=1;return}if(!a.yes&&!await i({message:`确认归档 plan-${o.currentPlan.number}？`})){console.log(`已取消`);return}let l=await n(o),u=r(l.archivedTo);console.log(`✅ 已归档: plan-${o.currentPlan.number} → done/${u}`),l.promoted!==null&&console.log(`📋 已晋升: plan-${l.promoted} 为新的当前计划`),l.remainingPreparing>0?console.log(`📋 待执行队列剩余 ${l.remainingPreparing} 个计划`):l.promoted===null&&console.log(`ℹ 无更多待执行计划`)}export{a as doneCommand};
+//# sourceMappingURL=done.js.map

package/dist/commands/done.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"done.js","names":[],"sources":["../../src/commands/done.ts"],"sourcesContent":["import { basename } from 'node:path'\n\nimport { confirm } from '@inquirer/prompts'\n\nimport { archive, readRawContext, validate } from '../context/index.js'\n\nexport async function doneCommand(options: { yes?: boolean }): Promise<void> {\n  const { snapshot, currentPlanCount } = await readRawContext(process.cwd())\n  const result = validate(snapshot, currentPlanCount)\n\n  if (!result.valid) {\n    for (const error of result.errors) {\n      console.log(`❌ ${error}`) // eslint-disable-line no-console\n    }\n    process.exitCode = 1\n    return\n  }\n\n  if (!snapshot || !snapshot.currentPlan) {\n    console.log('❌ 无当前计划') // eslint-disable-line no-console\n    process.exitCode = 1\n    return\n  }\n\n  if (snapshot.currentPlan.status !== '已执行') {\n    console.log(`❌ 当前计划 plan-${snapshot.currentPlan.number} 尚未执行，无法归档。`) // eslint-disable-line no-console\n    process.exitCode = 1\n    return\n  }\n\n  if (!options.yes) {\n    const confirmed = await confirm({\n      message: `确认归档 plan-${snapshot.currentPlan.number}？`\n    })\n    if (!confirmed) {\n      console.log('已取消') // eslint-disable-line no-console\n      return\n    }\n  }\n\n  const archiveResult = await archive(snapshot)\n  const archiveName = basename(archiveResult.archivedTo)\n\n  console.log(`✅ 已归档: plan-${snapshot.currentPlan.number} → done/${archiveName}`) // eslint-disable-line no-console\n\n  if (archiveResult.promoted !== null) {\n    console.log(`📋 已晋升: plan-${archiveResult.promoted} 为新的当前计划`) // eslint-disable-line no-console\n  }\n\n  if (archiveResult.remainingPreparing > 0) {\n    console.log(`📋 待执行队列剩余 ${archiveResult.remainingPreparing} 个计划`) // eslint-disable-line no-console\n  } else if (archiveResult.promoted === null) {\n    console.log('ℹ 无更多待执行计划') // eslint-disable-line no-console\n  }\n}\n"],"mappings":"2OAMA,eAAsB,EAAY,EAA2C,CAC3E,GAAM,CAAE,WAAU,oBAAqB,MAAM,EAAe,QAAQ,KAAK,CAAC,CACpE,EAAS,EAAS,EAAU,EAAiB,CAEnD,GAAI,CAAC,EAAO,MAAO,CACjB,IAAK,IAAM,KAAS,EAAO,OACzB,QAAQ,IAAI,KAAK,IAAQ,CAE3B,QAAQ,SAAW,EACnB,OAGF,GAAI,CAAC,GAAY,CAAC,EAAS,YAAa,CACtC,QAAQ,IAAI,UAAU,CACtB,QAAQ,SAAW,EACnB,OAGF,GAAI,EAAS,YAAY,SAAW,MAAO,CACzC,QAAQ,IAAI,eAAe,EAAS,YAAY,OAAO,aAAa,CACpE,QAAQ,SAAW,EACnB,OAGF,GAAI,CAAC,EAAQ,KAIP,CAHc,MAAM,EAAQ,CAC9B,QAAS,aAAa,EAAS,YAAY,OAAO,GACnD,CAAC,CACc,CACd,QAAQ,IAAI,MAAM,CAClB,OAIJ,IAAM,EAAgB,MAAM,EAAQ,EAAS,CACvC,EAAc,EAAS,EAAc,WAAW,CAEtD,QAAQ,IAAI,eAAe,EAAS,YAAY,OAAO,UAAU,IAAc,CAE3E,EAAc,WAAa,MAC7B,QAAQ,IAAI,gBAAgB,EAAc,SAAS,UAAU,CAG3D,EAAc,mBAAqB,EACrC,QAAQ,IAAI,cAAc,EAAc,mBAAmB,MAAM,CACxD,EAAc,WAAa,MACpC,QAAQ,IAAI,aAAa"}

package/dist/commands/install.js

@@ -0,0 +1,2 @@
+import{DEFAULT_TOOL_ORDER as e,detectConfiguredToolIds as t,getToolChoices as n,parseToolIds as r}from"../tools.js";import{runInstall as i}from"../runner.js";import{printCheckResult as a,printRunSummary as o}from"./printer.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]:s({message:`请选择要安装 ac-workflow Skill 的工具（可多选）：`,choices:n().map(e=>({name:e.name,value:e.id,checked:r.includes(e.id)})),required:!0})}return r(o)}export{c as installCommand};
+//# sourceMappingURL=install.js.map

package/dist/commands/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","names":[],"sources":["../../src/commands/install.ts"],"sourcesContent":["import { checkbox } from '@inquirer/prompts'\n\nimport { runInstall } from '../runner.js'\nimport { DEFAULT_TOOL_ORDER, detectConfiguredToolIds, getToolChoices, parseToolIds } from '../tools.js'\nimport type { ToolId } from '../types.js'\nimport { printCheckResult, printRunSummary } from './printer.js'\n\nexport interface InstallCommandOptions {\n  tools?: string\n  check?: boolean\n  yes?: boolean\n}\n\nexport async function installCommand(options: InstallCommandOptions = {}): Promise<void> {\n  const cwd = process.cwd()\n  const tools = await resolveTools(cwd, options)\n  const check = options.check ?? false\n  const result = await runInstall({ 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(\n  cwd: string,\n  options: InstallCommandOptions\n): 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      return configuredTools.length > 0 ? configuredTools : [...DEFAULT_TOOL_ORDER]\n    }\n\n    return checkbox<ToolId>({\n      message: '请选择要安装 ac-workflow Skill 的工具（可多选）：',\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\n  return parseToolIds(raw)\n}\n"],"mappings":"gRAaA,eAAsB,EAAe,EAAiC,EAAE,CAAiB,CACvF,IAAM,EAAM,QAAQ,KAAK,CACnB,EAAQ,MAAM,EAAa,EAAK,EAAQ,CACxC,EAAQ,EAAQ,OAAS,GACzB,EAAS,MAAM,EAAW,CAAE,MAAK,QAAO,QAAO,CAAC,CAEtD,GAAI,EAAO,CACT,EAAiB,EAAQ,EAAI,CACzB,EAAO,QAAQ,OAAS,IAC1B,QAAQ,SAAW,GAErB,OAGF,EAAgB,EAAQ,EAAI,CAG9B,eAAe,EACb,EACA,EAC+B,CAC/B,IAAM,EAAM,EAAQ,MAEpB,GAAI,CAAC,GAAO,EAAI,MAAM,CAAC,SAAW,EAAG,CACnC,IAAM,EAAkB,EAAwB,EAAI,CAMpD,OAJI,EAAQ,IACH,EAAgB,OAAS,EAAI,EAAkB,CAAC,GAAG,EAAmB,CAGxE,EAAiB,CACtB,QAAS,qCACT,QAAS,GAAgB,CAAC,IAAK,IAAU,CACvC,KAAM,EAAK,KACX,MAAO,EAAK,GACZ,QAAS,EAAgB,SAAS,EAAK,GAAG,CAC3C,EAAE,CACH,SAAU,GACX,CAAC,CAGJ,OAAO,EAAa,EAAI"}

package/dist/commands/printer.js

@@ -0,0 +1,4 @@
+import{relative as e}from"node:path";function t(t,n){if(console.log(`\n✅ ac-workflow ${t.mode} 完成`),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=printer.js.map

package/dist/commands/printer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"printer.js","names":[],"sources":["../../src/commands/printer.ts"],"sourcesContent":["import { relative } from 'node:path'\n\nimport type { RunResult } from '../types.js'\n\nexport function printRunSummary(result: RunResult, cwd: string): void {\n  console.log(`\\n✅ ac-workflow ${result.mode} 完成`) // 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,CAGpE,GAFA,QAAQ,IAAI,mBAAmB,EAAO,KAAK,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/status.js

@@ -0,0 +1,2 @@
+import{readRawContext as e}from"../context/reader.js";import{validate as t}from"../context/validator.js";async function n(){let{snapshot:n,currentPlanCount:r}=await e(process.cwd()),i=t(n,r);if(!i.valid){for(let e of i.errors)console.log(`❌ ${e}`);process.exitCode=1;return}if(i.context===null){console.log(`ℹ 无活跃上下文`);return}let a=i.context,o=a.currentPlan?`plan-${a.currentPlan.number} (${a.currentPlan.status})`:`无`,s=a.preparing.length>0?a.preparing.map(e=>`plan-${e.number}`).join(`, `):`无`;console.log(``),console.log(`Agent Context Status`),console.log(`────────────────────`),console.log(`当前计划:  ${o}`),console.log(`待执行队列: ${s}`),console.log(`已归档:    ${a.doneCount} 个`)}export{n as statusCommand};
+//# sourceMappingURL=status.js.map

package/dist/commands/status.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"status.js","names":[],"sources":["../../src/commands/status.ts"],"sourcesContent":["import { readRawContext, validate } from '../context/index.js'\n\nexport async function statusCommand(): Promise<void> {\n  const { snapshot, currentPlanCount } = await readRawContext(process.cwd())\n  const result = validate(snapshot, currentPlanCount)\n\n  if (!result.valid) {\n    for (const error of result.errors) {\n      console.log(`❌ ${error}`) // eslint-disable-line no-console\n    }\n    process.exitCode = 1\n    return\n  }\n\n  if (result.context === null) {\n    console.log('ℹ 无活跃上下文') // eslint-disable-line no-console\n    return\n  }\n\n  const ctx = result.context\n  const current = ctx.currentPlan\n    ? `plan-${ctx.currentPlan.number} (${ctx.currentPlan.status})`\n    : '无'\n  const preparing =\n    ctx.preparing.length > 0\n      ? ctx.preparing.map((p) => `plan-${p.number}`).join(', ')\n      : '无'\n\n  console.log('') // eslint-disable-line no-console\n  console.log('Agent Context Status') // eslint-disable-line no-console\n  console.log('────────────────────') // eslint-disable-line no-console\n  console.log(`当前计划:  ${current}`) // eslint-disable-line no-console\n  console.log(`待执行队列: ${preparing}`) // eslint-disable-line no-console\n  console.log(`已归档:    ${ctx.doneCount} 个`) // eslint-disable-line no-console\n}\n"],"mappings":"yGAEA,eAAsB,GAA+B,CACnD,GAAM,CAAE,WAAU,oBAAqB,MAAM,EAAe,QAAQ,KAAK,CAAC,CACpE,EAAS,EAAS,EAAU,EAAiB,CAEnD,GAAI,CAAC,EAAO,MAAO,CACjB,IAAK,IAAM,KAAS,EAAO,OACzB,QAAQ,IAAI,KAAK,IAAQ,CAE3B,QAAQ,SAAW,EACnB,OAGF,GAAI,EAAO,UAAY,KAAM,CAC3B,QAAQ,IAAI,WAAW,CACvB,OAGF,IAAM,EAAM,EAAO,QACb,EAAU,EAAI,YAChB,QAAQ,EAAI,YAAY,OAAO,IAAI,EAAI,YAAY,OAAO,GAC1D,IACE,EACJ,EAAI,UAAU,OAAS,EACnB,EAAI,UAAU,IAAK,GAAM,QAAQ,EAAE,SAAS,CAAC,KAAK,KAAK,CACvD,IAEN,QAAQ,IAAI,GAAG,CACf,QAAQ,IAAI,uBAAuB,CACnC,QAAQ,IAAI,uBAAuB,CACnC,QAAQ,IAAI,UAAU,IAAU,CAChC,QAAQ,IAAI,UAAU,IAAY,CAClC,QAAQ,IAAI,WAAW,EAAI,UAAU,IAAI"}

package/dist/commands/sync.js

@@ -0,0 +1,2 @@
+import{detectConfiguredToolIds as e,parseToolIds as t}from"../tools.js";import{runSync as n}from"../runner.js";import{printCheckResult as r,printRunSummary as i}from"./printer.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)return t;throw Error(`未检测到已安装的 Skill，请先执行 install 或通过 --tools 显式指定工具`)}return t(r)}export{a as syncCommand};
+//# sourceMappingURL=sync.js.map

package/dist/commands/sync.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sync.js","names":[],"sources":["../../src/commands/sync.ts"],"sourcesContent":["import { detectConfiguredToolIds, parseToolIds } from '../tools.js'\nimport type { ToolId } from '../types.js'\nimport { runSync } from '../runner.js'\nimport { printCheckResult, printRunSummary } from './printer.js'\n\nexport interface SyncCommandOptions {\n  tools?: string\n  check?: boolean\n}\n\nexport async function syncCommand(options: SyncCommandOptions = {}): Promise<void> {\n  const cwd = process.cwd()\n  const tools = resolveTools(cwd, options.tools)\n  const check = options.check ?? false\n  const result = await runSync({ 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\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      return configuredTools\n    }\n\n    throw new Error('未检测到已安装的 Skill，请先执行 install 或通过 --tools 显式指定工具')\n  }\n\n  return parseToolIds(raw)\n}\n"],"mappings":"oLAUA,eAAsB,EAAY,EAA8B,EAAE,CAAiB,CACjF,IAAM,EAAM,QAAQ,KAAK,CACnB,EAAQ,EAAa,EAAK,EAAQ,MAAM,CACxC,EAAQ,EAAQ,OAAS,GACzB,EAAS,MAAM,EAAQ,CAAE,MAAK,QAAO,QAAO,CAAC,CAEnD,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,OAAS,EAC3B,OAAO,EAGT,MAAU,MAAM,iDAAiD,CAGnE,OAAO,EAAa,EAAI"}

package/dist/commands/validate.js

@@ -0,0 +1,2 @@
+import{readRawContext as e}from"../context/reader.js";import{validate as t}from"../context/validator.js";async function n(){let{snapshot:n,currentPlanCount:r}=await e(process.cwd()),i=t(n,r);if(i.context===null){console.log(`ℹ 无 .agent-context 目录`);return}if(i.valid){console.log(`✅ 校验通过`);let e=i.context,t=e.currentPlan?`plan-${e.currentPlan.number} (${e.currentPlan.status})`:`无`;console.log(`  当前计划: ${t}`),console.log(`  待执行: ${e.preparing.length} 个`),console.log(`  已归档: ${e.doneCount} 个`);return}for(let e of i.errors)console.log(`❌ ${e}`);process.exitCode=1}export{n as validateCommand};
+//# sourceMappingURL=validate.js.map

package/dist/commands/validate.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate.js","names":[],"sources":["../../src/commands/validate.ts"],"sourcesContent":["import { readRawContext, validate } from '../context/index.js'\n\nexport async function validateCommand(): Promise<void> {\n  const { snapshot, currentPlanCount } = await readRawContext(process.cwd())\n  const result = validate(snapshot, currentPlanCount)\n\n  if (result.context === null) {\n    console.log('ℹ 无 .agent-context 目录') // eslint-disable-line no-console\n    return\n  }\n\n  if (result.valid) {\n    console.log('✅ 校验通过') // eslint-disable-line no-console\n    const ctx = result.context\n    const current = ctx.currentPlan\n      ? `plan-${ctx.currentPlan.number} (${ctx.currentPlan.status})`\n      : '无'\n    console.log(`  当前计划: ${current}`) // eslint-disable-line no-console\n    console.log(`  待执行: ${ctx.preparing.length} 个`) // eslint-disable-line no-console\n    console.log(`  已归档: ${ctx.doneCount} 个`) // eslint-disable-line no-console\n    return\n  }\n\n  for (const error of result.errors) {\n    console.log(`❌ ${error}`) // eslint-disable-line no-console\n  }\n  process.exitCode = 1\n}\n"],"mappings":"yGAEA,eAAsB,GAAiC,CACrD,GAAM,CAAE,WAAU,oBAAqB,MAAM,EAAe,QAAQ,KAAK,CAAC,CACpE,EAAS,EAAS,EAAU,EAAiB,CAEnD,GAAI,EAAO,UAAY,KAAM,CAC3B,QAAQ,IAAI,wBAAwB,CACpC,OAGF,GAAI,EAAO,MAAO,CAChB,QAAQ,IAAI,SAAS,CACrB,IAAM,EAAM,EAAO,QACb,EAAU,EAAI,YAChB,QAAQ,EAAI,YAAY,OAAO,IAAI,EAAI,YAAY,OAAO,GAC1D,IACJ,QAAQ,IAAI,WAAW,IAAU,CACjC,QAAQ,IAAI,UAAU,EAAI,UAAU,OAAO,IAAI,CAC/C,QAAQ,IAAI,UAAU,EAAI,UAAU,IAAI,CACxC,OAGF,IAAK,IAAM,KAAS,EAAO,OACzB,QAAQ,IAAI,KAAK,IAAQ,CAE3B,QAAQ,SAAW"}

package/dist/content/actions.js

@@ -0,0 +1,177 @@
+const e=[`init`,`plan`,`replan`,`implement`,`patch`,`rush`],t={init:n,plan:r,replan:i,implement:a,patch:o,rush:s};function n(){return`# init
+
+初始化项目的 Agent Context 上下文。根据新旧项目类型处理 \`AGENTS.md\`，新项目会自动进入计划创建流程。
+
+可附带描述参数，用于补充项目背景、技术栈、特殊约束。
+
+## 执行步骤
+
+1. **判断项目类型**：检测根目录是否存在有效代码文件和目录结构。
+   - 新项目：无实质代码，或用户明确说明是新项目。
+   - 旧项目：已有代码、配置文件和目录结构。
+   - 无法判断 → 向用户提问澄清，不可假设。
+
+2. **处理 AGENTS.md**：
+   - 新项目：
+     1. 通过提问澄清以下要点（已从描述中获取的可跳过）：项目目标与核心功能、技术栈与版本、代码规范与工具链（lint/formatter/测试）、目录结构偏好。
+     2. 生成高质量 \`AGENTS.md\`（须满足下方质量标准，不满足则重新优化直至满足）。
+     3. 继续执行 plan 创建初始计划。
+   - 旧项目：
+     1. 若不存在 \`AGENTS.md\`：通过提问与代码阅读收集信息后生成。
+     2. 若已存在 \`AGENTS.md\`：按质量标准评估，不足时增补优化。
+     3. 默认不创建计划（除非用户明确要求）。
+
+3. **输出反馈**：向用户报告项目类型判定结果、AGENTS.md 处理结果、是否需要后续计划。
+
+## 高质量 AGENTS.md 标准
+
+- 常用命令与约束前置，降低代理执行歧义。
+- 明确列出目录结构（至少到第二层）。
+- 明确标注技术栈及版本。
+- 明确代码风格约束（命名规范、格式化工具、lint 配置）。
+- 内容精简，无冗余段落或模板化填充。
+- 大型单体仓库按子包拆分维护本地 \`AGENTS.md\`。
+`}function r(){return`# plan
+
+创建新的执行计划，写入 \`.agent-context/plan-{number}/plan.md\`。按复杂度可拆分为多个计划，维护「单当前计划 + preparing 队列」结构。
+
+必须附带计划描述。
+
+## 前置检查
+
+- 运行 \`agent-context validate\`，不通过则中止并报告错误。
+- 描述为空 → 拒绝执行。
+- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 \`agent-context done\` 归档。
+- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
+
+## 执行步骤
+
+1. **需求澄清**（存在以下任一歧义时必须提问，否则跳到步骤 2）：
+   - 范围边界不清：无法判定影响哪些文件或模块。
+   - 存在显著不同的技术路径需用户决策。
+   - 验收标准不明确：无法判断何时算"完成"。
+2. 按复杂度决定单计划或多计划拆分。
+3. 多计划拆分时：最小编号进入 \`.agent-context/\` 作为当前计划，其余进入 \`.agent-context/preparing/\`。单计划直接创建。
+4. 每个计划创建 \`plan.md\`，遵循下方模板。
+5. **自检**（不通过则修改后重新检查）：
+   - 每个步骤可独立执行且有明确完成标准。
+   - 不存在过度拆分或拆分不足。
+   - 影响范围可预估。
+
+## plan.md 模板
+
+\`\`\`markdown
+# {计划名称}
+
+> 状态: 未执行
+
+## 目标
+
+{明确的目标描述}
+
+## 内容
+
+{详细的实施步骤}
+
+## 影响范围
+
+## 历史补丁
+\`\`\`
+
+- 状态行唯一，仅允许 \`未执行\` 或 \`已执行\`。
+- \`## 目标\` 与 \`## 内容\` 不可为空。
+- \`## 影响范围\` 与 \`## 历史补丁\` 创建时留空，后续由 implement 和 patch 写入。
+`}function i(){return`# replan
+
+重新规划已有的未实施计划，保持「单当前计划 + preparing 队列」结构不变。
+
+必须附带重规划描述。
+
+## 前置检查
+
+- 运行 \`agent-context validate\`，不通过则中止并报告错误。
+- 描述为空 → 拒绝执行。
+- 无未实施计划 → 拒绝执行，提示使用 plan 创建。
+- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
+- 目标计划编号不存在 → 拒绝执行，列出可选编号。
+- 目标计划已执行 → 拒绝执行，提示使用 patch。
+
+## 作用域
+
+- 默认作用域：\`.agent-context/preparing/\` 中全部未实施计划。
+- 可通过描述指定仅重规划部分计划（如"重规划 plan-3 和 plan-5"）。
+- 当前计划为 \`已执行\` → 禁止重写，仅允许重规划 \`preparing/\` 队列。
+- 当前计划为 \`未执行\` 且用户明确要求 → 可纳入重规划范围。
+
+## 执行步骤
+
+1. 解析描述，确定重规划目标范围。
+2. 读取目标计划 \`plan.md\`，理解现有意图。
+3. 生成新的拆分方案，保持「单当前计划 + 若干 preparing 计划」结构。
+4. 新增计划编号：全局 max(N)+1 递增分配；未改动计划保持原编号。
+5. 更新目录结构，确保每个新计划的 \`plan.md\` 遵循标准模板。
+`}function a(){return"# implement\n\n实施当前计划 `.agent-context/plan-{number}/plan.md` 中的全部步骤，通过验证循环后将状态更新为「已执行」。\n\n不接受额外描述。\n\n## 前置检查\n\n- 运行 `agent-context validate`，不通过则中止并报告错误。\n- 带描述 → 拒绝执行。\n- 当前计划不存在 → 拒绝执行，提示先创建计划。\n- 当前计划状态为 `已执行` → 拒绝执行，提示使用 patch 修补或运行 `agent-context done` 归档。\n- `## 目标` 或 `## 内容` 为空 → 拒绝执行，提示补充。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 仅操作当前计划，不直接操作 `preparing/` 中的计划。\n- 遇到阻塞问题应向用户报告，不可静默跳过。\n\n## 执行步骤\n\n1. 读取当前计划 `plan.md`，理解 `## 目标` 与 `## 内容`。\n2. 依据 `## 内容` 中的步骤逐项实施。\n3. **验证循环**（全部通过前不可进入步骤 4）：\n   a. 逐项对照 `## 内容` 确认每个步骤已实施。\n   b. 运行项目验证：类型检查 → lint → 测试。\n   c. 若存在失败项 → 修复后回到 a 重新验证。\n   d. 全部通过 → 进入步骤 4。\n4. 更新 `plan.md` 状态行：`> 状态: 未执行` → `> 状态: 已执行`。\n5. 更新 `## 影响范围`，记录所有变更文件。\n"}function o(){return`# patch
+
+基于当前已执行计划创建增量补丁，修复问题或追加变更。
+
+必须附带补丁描述。
+
+## 前置检查
+
+- 运行 \`agent-context validate\`，不通过则中止并报告错误。
+- 描述为空 → 拒绝执行。
+- 当前计划不存在 → 拒绝执行，提示先创建计划。
+- 当前计划状态为 \`未执行\` → 拒绝执行，提示先实施。
+- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。
+- 补丁不改变计划状态，完成后保持 \`已执行\`。
+
+## 执行步骤
+
+1. 阅读 \`plan.md\` 与已有 \`patch-{number}.md\`，了解上下文与历史，避免重复修复。
+2. 根据描述执行补丁所需的代码变更。
+3. 完成必要验证（测试、类型检查等）。
+4. 创建 \`patch-{number}.md\`（编号：扫描当前计划目录已有补丁取 max+1），遵循下方模板。
+5. 回写 \`plan.md\`：
+   - \`## 历史补丁\`：追加 \`- patch-{number}: {补丁名称}\`，按编号去重。
+   - \`## 影响范围\`：合并本次变更路径，按路径去重。
+
+## patch.md 模板
+
+\`\`\`markdown
+# {补丁名称}
+
+## 补丁内容
+
+{修改了什么、为什么修改}
+
+## 影响范围
+
+- 新增文件: \`/path/to/file\`
+- 修改文件: \`/path/to/file\`
+- 删除文件: \`/path/to/file\`
+\`\`\`
+`}function s(){return`# rush
+
+快速通道：创建计划并立即实施，适合范围明确、无需多轮规划的任务。
+
+必须附带任务描述。
+
+## 前置检查
+
+- 运行 \`agent-context validate\`，不通过则中止并报告错误。
+- 描述为空 → 拒绝执行。
+- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 \`agent-context done\` 归档。
+- 存在未实施的当前计划 → 拒绝执行，提示先 implement 或 replan。
+
+## 执行步骤
+
+1. 按 plan 协议创建单计划（不拆分，不进入 preparing 队列）。
+2. 无需用户确认计划内容，直接进入 implement 流程。
+3. 按 implement 协议执行全部步骤，包括验证循环：
+   a. 逐项对照 \`## 内容\` 确认每个步骤已实施。
+   b. 运行项目验证：类型检查 → lint → 测试。
+   c. 若存在失败项 → 修复后重新验证。
+   d. 全部通过 → 进入步骤 4。
+4. 更新 \`plan.md\` 状态行为 \`已执行\`，更新 \`## 影响范围\`。
+`}export{e as ACTION_NAMES,t as ACTION_RENDERERS};
+//# sourceMappingURL=actions.js.map

package/dist/content/actions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"actions.js","names":[],"sources":["../../src/content/actions.ts"],"sourcesContent":["export const ACTION_NAMES = ['init', 'plan', 'replan', 'implement', 'patch', 'rush'] as const\ntype ActionName = (typeof ACTION_NAMES)[number]\n\nexport const ACTION_RENDERERS: Record<ActionName, () => string> = {\n  init: renderInit,\n  plan: renderPlan,\n  replan: renderReplan,\n  implement: renderImplement,\n  patch: renderPatch,\n  rush: renderRush\n}\n\nfunction renderInit(): string {\n  return `# init\n\n初始化项目的 Agent Context 上下文。根据新旧项目类型处理 \\`AGENTS.md\\`，新项目会自动进入计划创建流程。\n\n可附带描述参数，用于补充项目背景、技术栈、特殊约束。\n\n## 执行步骤\n\n1. **判断项目类型**：检测根目录是否存在有效代码文件和目录结构。\n   - 新项目：无实质代码，或用户明确说明是新项目。\n   - 旧项目：已有代码、配置文件和目录结构。\n   - 无法判断 → 向用户提问澄清，不可假设。\n\n2. **处理 AGENTS.md**：\n   - 新项目：\n     1. 通过提问澄清以下要点（已从描述中获取的可跳过）：项目目标与核心功能、技术栈与版本、代码规范与工具链（lint/formatter/测试）、目录结构偏好。\n     2. 生成高质量 \\`AGENTS.md\\`（须满足下方质量标准，不满足则重新优化直至满足）。\n     3. 继续执行 plan 创建初始计划。\n   - 旧项目：\n     1. 若不存在 \\`AGENTS.md\\`：通过提问与代码阅读收集信息后生成。\n     2. 若已存在 \\`AGENTS.md\\`：按质量标准评估，不足时增补优化。\n     3. 默认不创建计划（除非用户明确要求）。\n\n3. **输出反馈**：向用户报告项目类型判定结果、AGENTS.md 处理结果、是否需要后续计划。\n\n## 高质量 AGENTS.md 标准\n\n- 常用命令与约束前置，降低代理执行歧义。\n- 明确列出目录结构（至少到第二层）。\n- 明确标注技术栈及版本。\n- 明确代码风格约束（命名规范、格式化工具、lint 配置）。\n- 内容精简，无冗余段落或模板化填充。\n- 大型单体仓库按子包拆分维护本地 \\`AGENTS.md\\`。\n`\n}\n\nfunction renderPlan(): string {\n  return `# plan\n\n创建新的执行计划，写入 \\`.agent-context/plan-{number}/plan.md\\`。按复杂度可拆分为多个计划，维护「单当前计划 + preparing 队列」结构。\n\n必须附带计划描述。\n\n## 前置检查\n\n- 运行 \\`agent-context validate\\`，不通过则中止并报告错误。\n- 描述为空 → 拒绝执行。\n- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 \\`agent-context done\\` 归档。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n\n## 执行步骤\n\n1. **需求澄清**（存在以下任一歧义时必须提问，否则跳到步骤 2）：\n   - 范围边界不清：无法判定影响哪些文件或模块。\n   - 存在显著不同的技术路径需用户决策。\n   - 验收标准不明确：无法判断何时算\"完成\"。\n2. 按复杂度决定单计划或多计划拆分。\n3. 多计划拆分时：最小编号进入 \\`.agent-context/\\` 作为当前计划，其余进入 \\`.agent-context/preparing/\\`。单计划直接创建。\n4. 每个计划创建 \\`plan.md\\`，遵循下方模板。\n5. **自检**（不通过则修改后重新检查）：\n   - 每个步骤可独立执行且有明确完成标准。\n   - 不存在过度拆分或拆分不足。\n   - 影响范围可预估。\n\n## plan.md 模板\n\n\\`\\`\\`markdown\n# {计划名称}\n\n> 状态: 未执行\n\n## 目标\n\n{明确的目标描述}\n\n## 内容\n\n{详细的实施步骤}\n\n## 影响范围\n\n## 历史补丁\n\\`\\`\\`\n\n- 状态行唯一，仅允许 \\`未执行\\` 或 \\`已执行\\`。\n- \\`## 目标\\` 与 \\`## 内容\\` 不可为空。\n- \\`## 影响范围\\` 与 \\`## 历史补丁\\` 创建时留空，后续由 implement 和 patch 写入。\n`\n}\n\nfunction renderReplan(): string {\n  return `# replan\n\n重新规划已有的未实施计划，保持「单当前计划 + preparing 队列」结构不变。\n\n必须附带重规划描述。\n\n## 前置检查\n\n- 运行 \\`agent-context validate\\`，不通过则中止并报告错误。\n- 描述为空 → 拒绝执行。\n- 无未实施计划 → 拒绝执行，提示使用 plan 创建。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 目标计划编号不存在 → 拒绝执行，列出可选编号。\n- 目标计划已执行 → 拒绝执行，提示使用 patch。\n\n## 作用域\n\n- 默认作用域：\\`.agent-context/preparing/\\` 中全部未实施计划。\n- 可通过描述指定仅重规划部分计划（如\"重规划 plan-3 和 plan-5\"）。\n- 当前计划为 \\`已执行\\` → 禁止重写，仅允许重规划 \\`preparing/\\` 队列。\n- 当前计划为 \\`未执行\\` 且用户明确要求 → 可纳入重规划范围。\n\n## 执行步骤\n\n1. 解析描述，确定重规划目标范围。\n2. 读取目标计划 \\`plan.md\\`，理解现有意图。\n3. 生成新的拆分方案，保持「单当前计划 + 若干 preparing 计划」结构。\n4. 新增计划编号：全局 max(N)+1 递增分配；未改动计划保持原编号。\n5. 更新目录结构，确保每个新计划的 \\`plan.md\\` 遵循标准模板。\n`\n}\n\nfunction renderImplement(): string {\n  return `# implement\n\n实施当前计划 \\`.agent-context/plan-{number}/plan.md\\` 中的全部步骤，通过验证循环后将状态更新为「已执行」。\n\n不接受额外描述。\n\n## 前置检查\n\n- 运行 \\`agent-context validate\\`，不通过则中止并报告错误。\n- 带描述 → 拒绝执行。\n- 当前计划不存在 → 拒绝执行，提示先创建计划。\n- 当前计划状态为 \\`已执行\\` → 拒绝执行，提示使用 patch 修补或运行 \\`agent-context done\\` 归档。\n- \\`## 目标\\` 或 \\`## 内容\\` 为空 → 拒绝执行，提示补充。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 仅操作当前计划，不直接操作 \\`preparing/\\` 中的计划。\n- 遇到阻塞问题应向用户报告，不可静默跳过。\n\n## 执行步骤\n\n1. 读取当前计划 \\`plan.md\\`，理解 \\`## 目标\\` 与 \\`## 内容\\`。\n2. 依据 \\`## 内容\\` 中的步骤逐项实施。\n3. **验证循环**（全部通过前不可进入步骤 4）：\n   a. 逐项对照 \\`## 内容\\` 确认每个步骤已实施。\n   b. 运行项目验证：类型检查 → lint → 测试。\n   c. 若存在失败项 → 修复后回到 a 重新验证。\n   d. 全部通过 → 进入步骤 4。\n4. 更新 \\`plan.md\\` 状态行：\\`> 状态: 未执行\\` → \\`> 状态: 已执行\\`。\n5. 更新 \\`## 影响范围\\`，记录所有变更文件。\n`\n}\n\nfunction renderPatch(): string {\n  return `# patch\n\n基于当前已执行计划创建增量补丁，修复问题或追加变更。\n\n必须附带补丁描述。\n\n## 前置检查\n\n- 运行 \\`agent-context validate\\`，不通过则中止并报告错误。\n- 描述为空 → 拒绝执行。\n- 当前计划不存在 → 拒绝执行，提示先创建计划。\n- 当前计划状态为 \\`未执行\\` → 拒绝执行，提示先实施。\n- 存在多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 补丁不改变计划状态，完成后保持 \\`已执行\\`。\n\n## 执行步骤\n\n1. 阅读 \\`plan.md\\` 与已有 \\`patch-{number}.md\\`，了解上下文与历史，避免重复修复。\n2. 根据描述执行补丁所需的代码变更。\n3. 完成必要验证（测试、类型检查等）。\n4. 创建 \\`patch-{number}.md\\`（编号：扫描当前计划目录已有补丁取 max+1），遵循下方模板。\n5. 回写 \\`plan.md\\`：\n   - \\`## 历史补丁\\`：追加 \\`- patch-{number}: {补丁名称}\\`，按编号去重。\n   - \\`## 影响范围\\`：合并本次变更路径，按路径去重。\n\n## patch.md 模板\n\n\\`\\`\\`markdown\n# {补丁名称}\n\n## 补丁内容\n\n{修改了什么、为什么修改}\n\n## 影响范围\n\n- 新增文件: \\`/path/to/file\\`\n- 修改文件: \\`/path/to/file\\`\n- 删除文件: \\`/path/to/file\\`\n\\`\\`\\`\n`\n}\n\nfunction renderRush(): string {\n  return `# rush\n\n快速通道：创建计划并立即实施，适合范围明确、无需多轮规划的任务。\n\n必须附带任务描述。\n\n## 前置检查\n\n- 运行 \\`agent-context validate\\`，不通过则中止并报告错误。\n- 描述为空 → 拒绝执行。\n- 存在未归档的已执行当前计划 → 拒绝执行，提示先运行 \\`agent-context done\\` 归档。\n- 存在未实施的当前计划 → 拒绝执行，提示先 implement 或 replan。\n\n## 执行步骤\n\n1. 按 plan 协议创建单计划（不拆分，不进入 preparing 队列）。\n2. 无需用户确认计划内容，直接进入 implement 流程。\n3. 按 implement 协议执行全部步骤，包括验证循环：\n   a. 逐项对照 \\`## 内容\\` 确认每个步骤已实施。\n   b. 运行项目验证：类型检查 → lint → 测试。\n   c. 若存在失败项 → 修复后重新验证。\n   d. 全部通过 → 进入步骤 4。\n4. 更新 \\`plan.md\\` 状态行为 \\`已执行\\`，更新 \\`## 影响范围\\`。\n`\n}\n"],"mappings":"AAAA,MAAa,EAAe,CAAC,OAAQ,OAAQ,SAAU,YAAa,QAAS,OAAO,CAGvE,EAAqD,CAChE,KAAM,EACN,KAAM,EACN,OAAQ,EACR,UAAW,EACX,MAAO,EACP,KAAM,EACP,CAED,SAAS,GAAqB,CAC5B,MAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAoCT,SAAS,GAAqB,CAC5B,MAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAqDT,SAAS,GAAuB,CAC9B,MAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAgCT,SAAS,GAA0B,CACjC,MAAO,wrBA+BT,SAAS,GAAsB,CAC7B,MAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CT,SAAS,GAAqB,CAC5B,MAAO"}

package/dist/content/index.js

@@ -0,0 +1,48 @@
+import{ACTION_NAMES as e,ACTION_RENDERERS as t}from"./actions.js";function n(n){let i=[{relativePath:`SKILL.md`,body:r(n)},...e.map(e=>({relativePath:`actions/${e}.md`,body:t[e]()}))];return n.metadataFiles.includes(`openai`)&&i.push({relativePath:`agents/openai.yaml`,body:a()}),{files:i}}function r(e){return`${i(e)}
+# Agent Context
+
+管理项目中的 \`.agent-context/\` 计划生命周期。匹配用户意图后，读取对应协议文件（相对于本文件所在目录）严格执行。
+
+## 意图匹配
+
+| 用户意图 | 动作 | 协议文件 |
+|----------|------|----------|
+| 初始化项目上下文、补全 AGENTS | init | \`actions/init.md\` |
+| 给需求出计划、拆分任务 | plan | \`actions/plan.md\` |
+| 重做计划、调整方案 | replan | \`actions/replan.md\` |
+| 按计划开始做、实现当前计划 | implement | \`actions/implement.md\` |
+| 补一个小改动、在当前结果上修 | patch | \`actions/patch.md\` |
+| 快速出计划并实施 | rush | \`actions/rush.md\` |
+| 任务彻底完成、归档当前计划 | done | 运行 \`agent-context done\` |
+
+## 全局约束
+
+- 状态机两态：\`未执行\`、\`已执行\`。
+- 任意时刻最多一个当前计划：\`.agent-context/plan-{number}\`。
+- 多个当前计划 → 拒绝执行，提示恢复单活跃状态。
+- 计划编号全局递增，不复用。补丁编号在单计划目录内递增，不复用。
+
+## 目录结构
+
+\`\`\`text
+.agent-context/
+├── plan-{N}/          # 当前计划（最多一个）
+│   ├── plan.md
+│   └── patch-{N}.md
+├── preparing/         # 待执行计划队列
+│   └── plan-{N}/
+└── done/              # 已归档计划
+    └── plan-{N}-{YYYYMMDD}/
+\`\`\`
+
+编号规则：扫描全部 \`plan-N\` 目录取 \`max(N)+1\`。
+`}function i(e){let t=[`---`,`name: ac-workflow`,`description: 管理 .agent-context 计划生命周期，按 init、plan、replan、implement、patch、rush、done 协议推进任务。`];return e.frontmatterProfile===`claude`&&t.push(`argument-hint: [request]`),e.frontmatterProfile===`copilot`&&t.push(`license: MIT`),t.push(`---`,``),`${t.join(`
+`)}\n`}function a(){return`interface:
+  display_name: "Agent Context"
+  short_description: "统一管理 .agent-context 计划生命周期"
+  default_prompt: "Use $ac-workflow to manage the current task through init, plan, replan, implement, patch, rush, or done."
+
+policy:
+  allow_implicit_invocation: true
+`}export{n as renderSkillArtifacts};
+//# sourceMappingURL=index.js.map

package/dist/content/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/content/index.ts"],"sourcesContent":["import type { SkillArtifacts, ToolTarget } from '../types.js'\nimport { ACTION_NAMES, ACTION_RENDERERS } from './actions.js'\n\nconst SKILL_NAME = 'ac-workflow'\nconst SKILL_DESCRIPTION =\n  '管理 .agent-context 计划生命周期，按 init、plan、replan、implement、patch、rush、done 协议推进任务。'\n\nexport function renderSkillArtifacts(target: ToolTarget): SkillArtifacts {\n  const files: SkillArtifacts['files'] = [\n    { relativePath: 'SKILL.md', body: renderNavigator(target) },\n    ...ACTION_NAMES.map((name) => ({\n      relativePath: `actions/${name}.md`,\n      body: ACTION_RENDERERS[name]()\n    }))\n  ]\n\n  if (target.metadataFiles.includes('openai')) {\n    files.push({ relativePath: 'agents/openai.yaml', body: renderOpenAIMetadata() })\n  }\n\n  return { files }\n}\n\n// ── Navigator ────────────────────────────────────────\n\nfunction renderNavigator(target: ToolTarget): string {\n  return `${renderFrontmatter(target)}\n# Agent Context\n\n管理项目中的 \\`.agent-context/\\` 计划生命周期。匹配用户意图后，读取对应协议文件（相对于本文件所在目录）严格执行。\n\n## 意图匹配\n\n| 用户意图 | 动作 | 协议文件 |\n|----------|------|----------|\n| 初始化项目上下文、补全 AGENTS | init | \\`actions/init.md\\` |\n| 给需求出计划、拆分任务 | plan | \\`actions/plan.md\\` |\n| 重做计划、调整方案 | replan | \\`actions/replan.md\\` |\n| 按计划开始做、实现当前计划 | implement | \\`actions/implement.md\\` |\n| 补一个小改动、在当前结果上修 | patch | \\`actions/patch.md\\` |\n| 快速出计划并实施 | rush | \\`actions/rush.md\\` |\n| 任务彻底完成、归档当前计划 | done | 运行 \\`agent-context done\\` |\n\n## 全局约束\n\n- 状态机两态：\\`未执行\\`、\\`已执行\\`。\n- 任意时刻最多一个当前计划：\\`.agent-context/plan-{number}\\`。\n- 多个当前计划 → 拒绝执行，提示恢复单活跃状态。\n- 计划编号全局递增，不复用。补丁编号在单计划目录内递增，不复用。\n\n## 目录结构\n\n\\`\\`\\`text\n.agent-context/\n├── plan-{N}/          # 当前计划（最多一个）\n│   ├── plan.md\n│   └── patch-{N}.md\n├── preparing/         # 待执行计划队列\n│   └── plan-{N}/\n└── done/              # 已归档计划\n    └── plan-{N}-{YYYYMMDD}/\n\\`\\`\\`\n\n编号规则：扫描全部 \\`plan-N\\` 目录取 \\`max(N)+1\\`。\n`\n}\n\n// ── Frontmatter & Metadata ──────────────────────────\n\nfunction renderFrontmatter(target: ToolTarget): string {\n  const lines = ['---', `name: ${SKILL_NAME}`, `description: ${SKILL_DESCRIPTION}`]\n\n  if (target.frontmatterProfile === 'claude') {\n    lines.push('argument-hint: [request]')\n  }\n\n  if (target.frontmatterProfile === 'copilot') {\n    lines.push('license: MIT')\n  }\n\n  lines.push('---', '')\n  return `${lines.join('\\n')}\\n`\n}\n\nfunction renderOpenAIMetadata(): string {\n  return `interface:\n  display_name: \"Agent Context\"\n  short_description: \"统一管理 .agent-context 计划生命周期\"\n  default_prompt: \"Use $ac-workflow to manage the current task through init, plan, replan, implement, patch, rush, or done.\"\n\npolicy:\n  allow_implicit_invocation: true\n`\n}\n"],"mappings":"kEAOA,SAAgB,EAAqB,EAAoC,CACvE,IAAM,EAAiC,CACrC,CAAE,aAAc,WAAY,KAAM,EAAgB,EAAO,CAAE,CAC3D,GAAG,EAAa,IAAK,IAAU,CAC7B,aAAc,WAAW,EAAK,KAC9B,KAAM,EAAiB,IAAO,CAC/B,EAAE,CACJ,CAMD,OAJI,EAAO,cAAc,SAAS,SAAS,EACzC,EAAM,KAAK,CAAE,aAAc,qBAAsB,KAAM,GAAsB,CAAE,CAAC,CAG3E,CAAE,QAAO,CAKlB,SAAS,EAAgB,EAA4B,CACnD,MAAO,GAAG,EAAkB,EAAO,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA2CtC,SAAS,EAAkB,EAA4B,CACrD,IAAM,EAAQ,CAAC,MAAO,oBAAuB,6FAAoC,CAWjF,OATI,EAAO,qBAAuB,UAChC,EAAM,KAAK,2BAA2B,CAGpC,EAAO,qBAAuB,WAChC,EAAM,KAAK,eAAe,CAG5B,EAAM,KAAK,MAAO,GAAG,CACd,GAAG,EAAM,KAAK;EAAK,CAAC,IAG7B,SAAS,GAA+B,CACtC,MAAO"}

package/dist/context/archiver.js

@@ -0,0 +1,2 @@
+import{join as e}from"node:path";import{mkdir as t,rename as n}from"node:fs/promises";async function r(r){if(!r.currentPlan)throw Error(`无当前计划`);if(r.currentPlan.status!==`已执行`)throw Error(`当前计划尚未执行`);let a=`plan-${r.currentPlan.number}-${i()}`,o=e(r.root,`done`),s=e(o,a);await t(o,{recursive:!0}),await n(r.currentPlan.dir,s);let c=null,l=r.preparing[0];if(l){let t=e(r.root,`plan-${l.number}`);await n(l.dir,t),c=l.number}return{archivedTo:s,promoted:c,remainingPreparing:r.preparing.length-(c===null?0:1)}}function i(){let e=new Date;return`${String(e.getFullYear())}${String(e.getMonth()+1).padStart(2,`0`)}${String(e.getDate()).padStart(2,`0`)}`}export{r as archive};
+//# sourceMappingURL=archiver.js.map

package/dist/context/archiver.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"archiver.js","names":[],"sources":["../../src/context/archiver.ts"],"sourcesContent":["import { rename, mkdir } from 'node:fs/promises'\nimport { join } from 'node:path'\n\nimport type { ArchiveResult, ContextSnapshot } from '../types.js'\n\nexport async function archive(context: ContextSnapshot): Promise<ArchiveResult> {\n  if (!context.currentPlan) {\n    throw new Error('无当前计划')\n  }\n\n  if (context.currentPlan.status !== '已执行') {\n    throw new Error('当前计划尚未执行')\n  }\n\n  const archiveName = `plan-${context.currentPlan.number}-${formatDate()}`\n  const doneDir = join(context.root, 'done')\n  const archivedTo = join(doneDir, archiveName)\n\n  await mkdir(doneDir, { recursive: true })\n  await rename(context.currentPlan.dir, archivedTo)\n\n  let promoted: number | null = null\n  const first = context.preparing[0]\n  if (first) {\n    const targetDir = join(context.root, `plan-${first.number}`)\n    await rename(first.dir, targetDir)\n    promoted = first.number\n  }\n\n  return {\n    archivedTo,\n    promoted,\n    remainingPreparing: context.preparing.length - (promoted !== null ? 1 : 0)\n  }\n}\n\n// ── Helpers ──────────────────────────────────────────\n\nfunction formatDate(): string {\n  const d = new Date()\n  const y = String(d.getFullYear())\n  const m = String(d.getMonth() + 1).padStart(2, '0')\n  const day = String(d.getDate()).padStart(2, '0')\n  return `${y}${m}${day}`\n}\n"],"mappings":"sFAKA,eAAsB,EAAQ,EAAkD,CAC9E,GAAI,CAAC,EAAQ,YACX,MAAU,MAAM,QAAQ,CAG1B,GAAI,EAAQ,YAAY,SAAW,MACjC,MAAU,MAAM,WAAW,CAG7B,IAAM,EAAc,QAAQ,EAAQ,YAAY,OAAO,GAAG,GAAY,GAChE,EAAU,EAAK,EAAQ,KAAM,OAAO,CACpC,EAAa,EAAK,EAAS,EAAY,CAE7C,MAAM,EAAM,EAAS,CAAE,UAAW,GAAM,CAAC,CACzC,MAAM,EAAO,EAAQ,YAAY,IAAK,EAAW,CAEjD,IAAI,EAA0B,KACxB,EAAQ,EAAQ,UAAU,GAChC,GAAI,EAAO,CACT,IAAM,EAAY,EAAK,EAAQ,KAAM,QAAQ,EAAM,SAAS,CAC5D,MAAM,EAAO,EAAM,IAAK,EAAU,CAClC,EAAW,EAAM,OAGnB,MAAO,CACL,aACA,WACA,mBAAoB,EAAQ,UAAU,QAAU,IAAa,KAAW,EAAJ,GACrE,CAKH,SAAS,GAAqB,CAC5B,IAAM,EAAI,IAAI,KAId,MAAO,GAHG,OAAO,EAAE,aAAa,CAAC,GACvB,OAAO,EAAE,UAAU,CAAG,EAAE,CAAC,SAAS,EAAG,IAAI,GACvC,OAAO,EAAE,SAAS,CAAC,CAAC,SAAS,EAAG,IAAI"}

package/dist/context/reader.js

@@ -0,0 +1,2 @@
+import{existsSync as e}from"node:fs";import{join as t}from"node:path";import{readFile as n,readdir as r}from"node:fs/promises";const i=/^plan-(\d+)$/,a=/^>\s*状态:\s*(未执行|已执行)\s*$/m;async function o(n){let r=t(n,`.agent-context`);if(!e(r))return{snapshot:null,currentPlanCount:0};let i=await c(r),a=await c(t(r,`preparing`)),o=await l(t(r,`done`));return{snapshot:{root:r,currentPlan:i[0]??null,preparing:a,doneCount:o},currentPlanCount:i.length}}async function s(r){let i=t(r,`plan.md`);if(!e(i))return`未执行`;let o=(await n(i,`utf-8`)).match(a);return o?o[1]:`未执行`}async function c(n){if(!e(n))return[];let a=await r(n,{withFileTypes:!0}),o=[];for(let e of a){if(!e.isDirectory())continue;let r=e.name.match(i);if(!r?.[1])continue;let a=parseInt(r[1],10),c=t(n,e.name),l=await s(c);o.push({number:a,status:l,dir:c})}return o.sort((e,t)=>e.number-t.number)}async function l(t){return e(t)?(await r(t,{withFileTypes:!0})).filter(e=>e.isDirectory()).length:0}export{o as readRawContext};
+//# sourceMappingURL=reader.js.map

package/dist/context/reader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"reader.js","names":[],"sources":["../../src/context/reader.ts"],"sourcesContent":["import { readdir, readFile } from 'node:fs/promises'\nimport { existsSync } from 'node:fs'\nimport { join } from 'node:path'\n\nimport type { ContextSnapshot, PlanInfo, PlanStatus } from '../types.js'\n\nconst PLAN_DIR_RE = /^plan-(\\d+)$/\nconst STATUS_RE = /^>\\s*状态:\\s*(未执行|已执行)\\s*$/m\n\n// ── Public API ───────────────────────────────────────\n\nexport async function readContext(cwd: string): Promise<ContextSnapshot | null> {\n  const { snapshot } = await readRawContext(cwd)\n  return snapshot\n}\n\nexport async function readRawContext(\n  cwd: string\n): Promise<{ snapshot: ContextSnapshot | null; currentPlanCount: number }> {\n  const root = join(cwd, '.agent-context')\n\n  if (!existsSync(root)) {\n    return { snapshot: null, currentPlanCount: 0 }\n  }\n\n  const currentPlans = await readPlanDirs(root)\n  const preparing = await readPlanDirs(join(root, 'preparing'))\n  const doneCount = await countDirs(join(root, 'done'))\n\n  const snapshot: ContextSnapshot = {\n    root,\n    currentPlan: currentPlans[0] ?? null,\n    preparing,\n    doneCount\n  }\n\n  return { snapshot, currentPlanCount: currentPlans.length }\n}\n\nexport async function readPlanStatus(planDir: string): Promise<PlanStatus> {\n  const planFile = join(planDir, 'plan.md')\n\n  if (!existsSync(planFile)) {\n    return '未执行'\n  }\n\n  const content = await readFile(planFile, 'utf-8')\n  const match = content.match(STATUS_RE)\n  return match ? (match[1] as PlanStatus) : '未执行'\n}\n\n// ── Helpers ──────────────────────────────────────────\n\nasync function readPlanDirs(parentDir: string): Promise<PlanInfo[]> {\n  if (!existsSync(parentDir)) return []\n\n  const entries = await readdir(parentDir, { withFileTypes: true })\n  const plans: PlanInfo[] = []\n\n  for (const entry of entries) {\n    if (!entry.isDirectory()) continue\n    const match = entry.name.match(PLAN_DIR_RE)\n    if (!match?.[1]) continue\n    const number = parseInt(match[1], 10)\n    const dir = join(parentDir, entry.name)\n    const status = await readPlanStatus(dir)\n    plans.push({ number, status, dir })\n  }\n\n  return plans.sort((a, b) => a.number - b.number)\n}\n\nasync function countDirs(dir: string): Promise<number> {\n  if (!existsSync(dir)) return 0\n  const entries = await readdir(dir, { withFileTypes: true })\n  return entries.filter(e => e.isDirectory()).length\n}\n"],"mappings":"+HAMA,MAAM,EAAc,eACd,EAAY,4BASlB,eAAsB,EACpB,EACyE,CACzE,IAAM,EAAO,EAAK,EAAK,iBAAiB,CAExC,GAAI,CAAC,EAAW,EAAK,CACnB,MAAO,CAAE,SAAU,KAAM,iBAAkB,EAAG,CAGhD,IAAM,EAAe,MAAM,EAAa,EAAK,CACvC,EAAY,MAAM,EAAa,EAAK,EAAM,YAAY,CAAC,CACvD,EAAY,MAAM,EAAU,EAAK,EAAM,OAAO,CAAC,CASrD,MAAO,CAAE,SAPyB,CAChC,OACA,YAAa,EAAa,IAAM,KAChC,YACA,YACD,CAEkB,iBAAkB,EAAa,OAAQ,CAG5D,eAAsB,EAAe,EAAsC,CACzE,IAAM,EAAW,EAAK,EAAS,UAAU,CAEzC,GAAI,CAAC,EAAW,EAAS,CACvB,MAAO,MAIT,IAAM,GADU,MAAM,EAAS,EAAU,QAAQ,EAC3B,MAAM,EAAU,CACtC,OAAO,EAAS,EAAM,GAAoB,MAK5C,eAAe,EAAa,EAAwC,CAClE,GAAI,CAAC,EAAW,EAAU,CAAE,MAAO,EAAE,CAErC,IAAM,EAAU,MAAM,EAAQ,EAAW,CAAE,cAAe,GAAM,CAAC,CAC3D,EAAoB,EAAE,CAE5B,IAAK,IAAM,KAAS,EAAS,CAC3B,GAAI,CAAC,EAAM,aAAa,CAAE,SAC1B,IAAM,EAAQ,EAAM,KAAK,MAAM,EAAY,CAC3C,GAAI,CAAC,IAAQ,GAAI,SACjB,IAAM,EAAS,SAAS,EAAM,GAAI,GAAG,CAC/B,EAAM,EAAK,EAAW,EAAM,KAAK,CACjC,EAAS,MAAM,EAAe,EAAI,CACxC,EAAM,KAAK,CAAE,SAAQ,SAAQ,MAAK,CAAC,CAGrC,OAAO,EAAM,MAAM,EAAG,IAAM,EAAE,OAAS,EAAE,OAAO,CAGlD,eAAe,EAAU,EAA8B,CAGrD,OAFK,EAAW,EAAI,EACJ,MAAM,EAAQ,EAAK,CAAE,cAAe,GAAM,CAAC,EAC5C,OAAO,GAAK,EAAE,aAAa,CAAC,CAAC,OAFf"}

package/dist/context/validator.js

@@ -0,0 +1,2 @@
+import{existsSync as e}from"node:fs";import{join as t}from"node:path";function n(n,r){if(n===null)return{valid:!0,errors:[],context:null};let i=[];r>1&&i.push(`存在 ${r} 个当前计划，应最多 1 个。`),n.currentPlan&&(e(t(n.currentPlan.dir,`plan.md`))||i.push(`当前计划 plan-${n.currentPlan.number} 缺少 plan.md。`));let a=[];n.currentPlan&&a.push(n.currentPlan.number);for(let e of n.preparing)a.push(e.number);let o=new Set,s=new Set;for(let e of a)o.has(e)&&s.add(e),o.add(e);if(s.size>0){let e=[...s].sort((e,t)=>e-t).join(`, `);i.push(`计划编号冲突: ${e}。`)}return{valid:i.length===0,errors:i,context:n}}export{n as validate};
+//# sourceMappingURL=validator.js.map

package/dist/context/validator.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"validator.js","names":[],"sources":["../../src/context/validator.ts"],"sourcesContent":["import { existsSync } from 'node:fs'\nimport { join } from 'node:path'\n\nimport type { ContextSnapshot, ValidateResult } from '../types.js'\n\nexport function validate(\n  snapshot: ContextSnapshot | null,\n  currentPlanCount: number\n): ValidateResult {\n  if (snapshot === null) {\n    return { valid: true, errors: [], context: null }\n  }\n\n  const errors: string[] = []\n\n  if (currentPlanCount > 1) {\n    errors.push(`存在 ${currentPlanCount} 个当前计划，应最多 1 个。`)\n  }\n\n  if (snapshot.currentPlan) {\n    const planMd = join(snapshot.currentPlan.dir, 'plan.md')\n    if (!existsSync(planMd)) {\n      errors.push(`当前计划 plan-${snapshot.currentPlan.number} 缺少 plan.md。`)\n    }\n  }\n\n  const allNumbers: number[] = []\n  if (snapshot.currentPlan) allNumbers.push(snapshot.currentPlan.number)\n  for (const p of snapshot.preparing) allNumbers.push(p.number)\n\n  const seen = new Set<number>()\n  const duplicates = new Set<number>()\n  for (const n of allNumbers) {\n    if (seen.has(n)) duplicates.add(n)\n    seen.add(n)\n  }\n\n  if (duplicates.size > 0) {\n    const nums = [...duplicates].sort((a, b) => a - b).join(', ')\n    errors.push(`计划编号冲突: ${nums}。`)\n  }\n\n  return { valid: errors.length === 0, errors, context: snapshot }\n}\n"],"mappings":"sEAKA,SAAgB,EACd,EACA,EACgB,CAChB,GAAI,IAAa,KACf,MAAO,CAAE,MAAO,GAAM,OAAQ,EAAE,CAAE,QAAS,KAAM,CAGnD,IAAM,EAAmB,EAAE,CAEvB,EAAmB,GACrB,EAAO,KAAK,MAAM,EAAiB,iBAAiB,CAGlD,EAAS,cAEN,EADU,EAAK,EAAS,YAAY,IAAK,UAAU,CACjC,EACrB,EAAO,KAAK,aAAa,EAAS,YAAY,OAAO,cAAc,EAIvE,IAAM,EAAuB,EAAE,CAC3B,EAAS,aAAa,EAAW,KAAK,EAAS,YAAY,OAAO,CACtE,IAAK,IAAM,KAAK,EAAS,UAAW,EAAW,KAAK,EAAE,OAAO,CAE7D,IAAM,EAAO,IAAI,IACX,EAAa,IAAI,IACvB,IAAK,IAAM,KAAK,EACV,EAAK,IAAI,EAAE,EAAE,EAAW,IAAI,EAAE,CAClC,EAAK,IAAI,EAAE,CAGb,GAAI,EAAW,KAAO,EAAG,CACvB,IAAM,EAAO,CAAC,GAAG,EAAW,CAAC,MAAM,EAAG,IAAM,EAAI,EAAE,CAAC,KAAK,KAAK,CAC7D,EAAO,KAAK,WAAW,EAAK,GAAG,CAGjC,MAAO,CAAE,MAAO,EAAO,SAAW,EAAG,SAAQ,QAAS,EAAU"}

package/dist/runner.js

@@ -0,0 +1,3 @@
+import{resolveSkillPaths as e,resolveToolTargets as t}from"./tools.js";import{renderSkillArtifacts as n}from"./content/index.js";import{existsSync as r}from"node:fs";import{dirname as i,resolve as a}from"node:path";import{mkdir as o,readFile as s,writeFile as c}from"node:fs/promises";async function l(e={}){return d(`install`,e)}async function u(e={}){return d(`sync`,e)}async function d(e,n){let r=n.cwd??process.cwd(),i=t(_(n.tools)).flatMap(e=>f(e,r)),a=n.check??!1;return{...await m(i,a),mode:e,check:a}}function f(t,r){let i=n(t),a=e(t,r);return i.files.map(e=>({path:p(a,e.relativePath),body:e.body}))}function p(e,t){return t===`SKILL.md`?e.skillFile:a(e.skillDir,t)}async function m(e,t){let n={created:[],updated:[],unchanged:[],changed:[]};for(let a of e){let e=r(a.path),s=await h(a,e);if(!s.changed){n.unchanged.push(a.path);continue}t||(await o(i(a.path),{recursive:!0}),await c(a.path,s.content,`utf-8`)),n.changed.push(a.path),e?n.updated.push(a.path):n.created.push(a.path)}return n}async function h(e,t){let n=g(e.body);return t?{content:n,changed:await s(e.path,`utf-8`)!==n}:{content:n,changed:!0}}function g(e){return e.endsWith(`
+`)?e:`${e}\n`}function _(e){if(!(!e||e.length===0))return[...new Set(e)]}export{l as runInstall,u as runSync};
+//# sourceMappingURL=runner.js.map

package/dist/runner.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.js","names":[],"sources":["../src/runner.ts"],"sourcesContent":["import { resolve, dirname } from 'node:path'\nimport { existsSync } from 'node:fs'\nimport { mkdir, readFile, writeFile } from 'node:fs/promises'\n\nimport type { SkillPaths } from './tools.js'\nimport { resolveToolTargets, resolveSkillPaths } from './tools.js'\nimport { renderSkillArtifacts } from './content/index.js'\nimport type { ApplyMutationResult, FileMutation, RunOptions, RunResult, ToolId, ToolTarget } from './types.js'\n\nexport async function runInstall(options: RunOptions = {}): Promise<RunResult> {\n  return run('install', options)\n}\n\nexport async function runSync(options: RunOptions = {}): Promise<RunResult> {\n  return run('sync', options)\n}\n\n// ── Orchestration ───────────────────────────────────\n\nasync function run(mode: 'install' | 'sync', options: RunOptions): Promise<RunResult> {\n  const cwd = options.cwd ?? process.cwd()\n  const tools = dedup(options.tools)\n  const targets = resolveToolTargets(tools)\n\n  const mutations: FileMutation[] = targets.flatMap(target => buildMutations(target, cwd))\n\n  const check = options.check ?? false\n  const result = await applyMutations(mutations, check)\n\n  return { ...result, mode, check }\n}\n\n// ── Mutation building ───────────────────────────────\n\nfunction buildMutations(target: ToolTarget, cwd: string): FileMutation[] {\n  const artifacts = renderSkillArtifacts(target)\n  const paths = resolveSkillPaths(target, cwd)\n\n  return artifacts.files.map(file => ({\n    path: resolveArtifactPath(paths, file.relativePath),\n    body: file.body\n  }))\n}\n\nfunction resolveArtifactPath(paths: SkillPaths, relativePath: string): string {\n  if (relativePath === 'SKILL.md') {\n    return paths.skillFile\n  }\n\n  return resolve(paths.skillDir, relativePath)\n}\n\n// ── Mutation application ────────────────────────────\n\nasync function applyMutations(\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 next = await resolveNextContent(mutation, fileExists)\n\n    if (!next.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, next.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 content = normalizeTrailingNewline(mutation.body)\n\n  if (!fileExists) {\n    return { content, changed: true }\n  }\n\n  const current = await readFile(mutation.path, 'utf-8')\n  return { content, changed: current !== content }\n}\n\nfunction normalizeTrailingNewline(content: string): string {\n  return content.endsWith('\\n') ? content : `${content}\\n`\n}\n\nfunction dedup(tools?: ToolId[]): ToolId[] | undefined {\n  if (!tools || tools.length === 0) return undefined\n  return [...new Set(tools)]\n}\n"],"mappings":"6RASA,eAAsB,EAAW,EAAsB,EAAE,CAAsB,CAC7E,OAAO,EAAI,UAAW,EAAQ,CAGhC,eAAsB,EAAQ,EAAsB,EAAE,CAAsB,CAC1E,OAAO,EAAI,OAAQ,EAAQ,CAK7B,eAAe,EAAI,EAA0B,EAAyC,CACpF,IAAM,EAAM,EAAQ,KAAO,QAAQ,KAAK,CAIlC,EAFU,EADF,EAAM,EAAQ,MAAM,CACO,CAEC,QAAQ,GAAU,EAAe,EAAQ,EAAI,CAAC,CAElF,EAAQ,EAAQ,OAAS,GAG/B,MAAO,CAAE,GAFM,MAAM,EAAe,EAAW,EAAM,CAEjC,OAAM,QAAO,CAKnC,SAAS,EAAe,EAAoB,EAA6B,CACvE,IAAM,EAAY,EAAqB,EAAO,CACxC,EAAQ,EAAkB,EAAQ,EAAI,CAE5C,OAAO,EAAU,MAAM,IAAI,IAAS,CAClC,KAAM,EAAoB,EAAO,EAAK,aAAa,CACnD,KAAM,EAAK,KACZ,EAAE,CAGL,SAAS,EAAoB,EAAmB,EAA8B,CAK5E,OAJI,IAAiB,WACZ,EAAM,UAGR,EAAQ,EAAM,SAAU,EAAa,CAK9C,eAAe,EACb,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,EAAO,MAAM,EAAmB,EAAU,EAAW,CAE3D,GAAI,CAAC,EAAK,QAAS,CACjB,EAAO,UAAU,KAAK,EAAS,KAAK,CACpC,SAGG,IACH,MAAM,EAAM,EAAQ,EAAS,KAAK,CAAE,CAAE,UAAW,GAAM,CAAC,CACxD,MAAM,EAAU,EAAS,KAAM,EAAK,QAAS,QAAQ,EAGvD,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,EAAU,EAAyB,EAAS,KAAK,CAOvD,OALK,EAKE,CAAE,UAAS,QADF,MAAM,EAAS,EAAS,KAAM,QAAQ,GACf,EAAS,CAJvC,CAAE,UAAS,QAAS,GAAM,CAOrC,SAAS,EAAyB,EAAyB,CACzD,OAAO,EAAQ,SAAS;EAAK,CAAG,EAAU,GAAG,EAAQ,IAGvD,SAAS,EAAM,EAAwC,CACjD,MAAC,GAAS,EAAM,SAAW,GAC/B,MAAO,CAAC,GAAG,IAAI,IAAI,EAAM,CAAC"}