cdspec 0.1.0 → 0.1.1

package/README.md

@@ -1,55 +1,108 @@
-# cdspec
+# CDSpec
 
-CLI for:
+`cdspec` 是一个 Skill 编排 CLI，用来把项目里的模板/技能一键安装到不同智能体目录（Codex / ClaudeCode / iFlow），并自动生成可调用命令。
 
-- Exporting project-local skills from `.codex/*` to `.codex/.claude/.iflow` tool layouts.
-- Installing OpenSpec-style interaction commands (`opsx-*`).
-- Splitting markdown into task cards and archiving completed tasks.
-- Config-driven command-skill bindings via `cdspec.config.yaml`.
+## 功能
 
-## Quick start
+- 从 `templates/` 批量生成并安装 skills
+- 自动为每个 skill 生成命令文件
+- 生成命令与 skill 的绑定说明（AGENTS/CLAUDE/IFLOW）
+- 支持任务拆分与归档（`task split/status/archive`）
+
+## 安装
+
+全局安装（已发布到 npm）：
+
+```bash
+npm i -g cdspec
+```
+
+验证安装：
+
+```bash
+cdspec --help
+```
+
+本地开发方式：
 
 ```bash
 npm install
 npm run build
-node dist/cli.js --help
+npm link
+```
+
+## 快速开始
+
+在项目根目录准备 `templates/`，每个技能一个目录，目录内至少有 `SKILL.md`。
+
+示例：
+
+```text
+templates/
+  design-doc/
+    SKILL.md
+    agents/openai.yaml
+    references/*
+  frontend-standards/
+    SKILL.md
 ```
 
-## Commands
+执行初始化：
 
 ```bash
-cdspec init --agents codex,claudecode,iflow
+cdspec init
+```
 
-cdspec skill list
-cdspec skill add <name> --target all
-cdspec skill sync --target all
+或指定智能体：
 
-cdspec task split --from plan.md --title "My Task"
-cdspec task status --id <task-id> --to in_progress
-cdspec task status --id <task-id> --to done
-cdspec task archive --id <task-id>
+```bash
+cdspec init --agents codex,claudecode,iflow
 ```
 
-`cdspec init` generates tool-local files:
+## 生成规则（当前版本）
+
+1. `templates/*` 下每个 skill 目录会被安装到目标智能体的 `skills/`。
+2. 每个 skill 自动生成一个命令文件，命令名规则为：
+   `cd-<skill-name>`
+3. `init` 默认覆盖旧文件（不需要 `--force`）。
+
+示例：
+
+- skill: `frontend-develop-standard`
+- 命令文件：`cd-frontend-develop-standard.md`
+
+## 输出目录
+
+默认配置下：
+
+- Codex: `~/.codex/skills/*` 和 `~/.codex/prompts/*`
+- ClaudeCode: `.claude/skills/*` 和 `.claude/commands/opsx/*`
+- iFlow: `.iflow/skills/*` 和 `.iflow/commands/*`
+
+附加说明文件：
+
+- `~/.codex/AGENTS.md`
+- 项目根 `AGENTS.md`
+- 项目根 `CLAUDE.md`（当启用 claudecode）
+- `.iflow/IFLOW.md`（当启用 iflow）
+
+## 配置
 
-- `.codex/skills/*`, `.codex/prompts/opsx-*.md`, `.codex/AGENTS.md`
-- `.claude/skills/*`, `.claude/commands/opsx/*.md`, `CLAUDE.md`
-- `.iflow/skills/*`, `.iflow/commands/opsx-*.md`, `.iflow/IFLOW.md`
+项目根配置文件：`cdspec.config.yaml`
 
-If `.codex` has no skills, `cdspec init` exports template skill directly into target `skills/` folders.
-It does not create extra source folders in your project tree.
-When `templates/*.md` exists, the exported skill name is derived from template filename, and
-command bindings are auto-pointed to that generated skill.
+可配置项包括：
 
-## Output
+- 各智能体根目录（如 `~/.codex`）
+- 命令目录位置（`prompts` / `commands`）
+- 命令文件命名规则与 slash 展示规则
 
-- Skill output: `.{tool}/skills/{skill-name}`
-- Task workspace: `.cdspec/tasks` and `.cdspec/archive`
+## 常见问题
 
-## Config
+1. `init` 后看不到新命令  
+   重启 Codex 会话；部分客户端启动时才扫描 prompt 列表。
 
-`cdspec.config.yaml` controls:
+2. 命令重复（Team/个人各一份）  
+   这是不同来源同时存在，清理个人或团队同名 skill 即可。
 
-- command -> skill bindings
-- per-agent root directory and command file pattern
-- slash command display pattern
+3. 发布 npm 报 401/404  
+   先 `npm login`，再检查包名与权限后发布。

package/dist/cli.js

@@ -1,74 +1,21 @@
 #!/usr/bin/env node
-import checkbox from "@inquirer/checkbox";
-import { Command } from "commander";
-import path from "node:path";
-import process from "node:process";
-import { addSkill, initSkills, listSkills, syncSkills } from "./skill-core/service.js";
-import { archiveTaskById, splitTasks, updateTask } from "./task-core/service.js";
+import checkbox from '@inquirer/checkbox';
+import { Command } from 'commander';
+import path from 'node:path';
+import process from 'node:process';
+import { initSkills } from './skill-core/service.js';
 const program = new Command();
+program.name('cdspec').description('Skill init CLI').version('0.1.0');
 program
-    .name("cdspec")
-    .description("Skill sync + task split/archive workflow CLI")
-    .version("0.1.0");
-program
-    .command("init")
-    .description("Initialize skills for selected coding agents")
-    .option("--agents <agents>", "codex|claudecode|iflow|all or comma-separated")
+    .command('init')
+    .description('Initialize skills for selected coding agents')
+    .option('--agents <agents>', 'codex|claudecode|iflow|all or comma-separated')
     .action(async (options) => {
     const selected = options.agents ?? (await askAgentsSelection());
     const files = await initSkills(process.cwd(), selected, true);
-    console.log(`Initialized OpenSpec-style setup for "${selected}".`);
-    console.log(`Generated files: ${files.map((x) => path.relative(process.cwd(), x)).join(", ")}`);
+    console.log(`Initialized setup for "${selected}".`);
+    console.log(`Generated files: ${files.map(x => path.relative(process.cwd(), x)).join(', ')}`);
 });
-program
-    .command("skill")
-    .description("Skill operations")
-    .addCommand(new Command("list").action(async () => {
-    const names = await listSkills(process.cwd());
-    if (names.length === 0) {
-        console.log("No skill found under .codex/.");
-        return;
-    }
-    names.forEach((name) => console.log(name));
-}))
-    .addCommand(new Command("add")
-    .argument("<name>", "skill folder name under .codex")
-    .option("--target <target>", "codex|claudecode|iflow|all or comma-separated", "all")
-    .option("--force", "overwrite existing output", false)
-    .action(async (name, options) => {
-    await addSkill(process.cwd(), name, options.target, options.force);
-    console.log(`Skill "${name}" exported to tool folders for target "${options.target}".`);
-}))
-    .addCommand(new Command("sync")
-    .option("--target <target>", "codex|claudecode|iflow|all or comma-separated", "all")
-    .option("--force", "overwrite existing output", false)
-    .action(async (options) => {
-    await syncSkills(process.cwd(), options.target, options.force);
-    console.log(`All skills synced to tool folders for target "${options.target}".`);
-}));
-program
-    .command("task")
-    .description("Task split/archive operations")
-    .addCommand(new Command("split")
-    .requiredOption("--from <file>", "source markdown file")
-    .requiredOption("--title <title>", "task group title")
-    .action(async (options) => {
-    const count = await splitTasks(process.cwd(), options.from, options.title);
-    console.log(`Generated ${count} tasks from "${options.from}".`);
-}))
-    .addCommand(new Command("status")
-    .requiredOption("--id <id>", "task id")
-    .requiredOption("--to <status>", "todo|in_progress|done")
-    .action(async (options) => {
-    await updateTask(process.cwd(), options.id, options.to);
-    console.log(`Task "${options.id}" updated to "${options.to}".`);
-}))
-    .addCommand(new Command("archive")
-    .requiredOption("--id <id>", "task id")
-    .action(async (options) => {
-    await archiveTaskById(process.cwd(), options.id);
-    console.log(`Task "${options.id}" archived.`);
-}));
 program.parseAsync(process.argv).catch((error) => {
     const message = error instanceof Error ? error.message : String(error);
     console.error(message);
@@ -76,19 +23,19 @@ program.parseAsync(process.argv).catch((error) => {
 });
 async function askAgentsSelection() {
     if (!process.stdin.isTTY)
-        return "all";
+        return 'all';
     const values = await checkbox({
-        message: "Select coding agents",
+        message: 'Select coding agents',
         choices: [
-            { name: "codex", value: "codex", checked: true },
-            { name: "claudecode", value: "claudecode" },
-            { name: "iflow", value: "iflow" },
-            { name: "all", value: "all" }
+            { name: 'codex', value: 'codex', checked: true },
+            { name: 'claudecode', value: 'claudecode' },
+            { name: 'iflow', value: 'iflow' },
+            { name: 'all', value: 'all' }
         ]
     });
     if (values.length === 0)
-        return "all";
-    if (values.includes("all"))
-        return "all";
-    return values.join(",");
+        return 'all';
+    if (values.includes('all'))
+        return 'all';
+    return values.join(',');
 }

package/dist/skill-core/manifest-loader.js

@@ -15,9 +15,6 @@ export async function loadAllSkillManifests(cwd) {
     }
     return manifests;
 }
-export async function loadSkillManifestByName(cwd, name) {
-    return loadSkillManifest(path.join(cwd, CODEX_DIR, name));
-}
 async function loadSkillManifest(skillDir) {
     const skillMdPath = path.join(skillDir, "SKILL.md");
     if (!(await pathExists(skillMdPath)))

package/dist/skill-core/service.js

@@ -2,58 +2,11 @@ import path from "node:path";
 import { rm } from "node:fs/promises";
 import { loadConfig } from "../config/loader.js";
 import { resolveAgentRoot } from "../config/path.js";
-import { loadAllSkillManifests, loadSkillManifestByName } from "./manifest-loader.js";
+import { loadAllSkillManifests } from "./manifest-loader.js";
 import { expandTargets, getAdapter } from "./adapters/index.js";
 import { installToolInteractionTemplates, writeSharedAgentsStub } from "./tool-interactions.js";
 import { cleanupLegacyDefaultSkillDir, loadDefaultSkillManifest, loadProjectTemplateManifests } from "./scaffold.js";
 import { validateManifest } from "./validator.js";
-export async function listSkills(cwd) {
-    const manifests = await loadAllSkillManifests(cwd);
-    return manifests.map((manifest) => manifest.name).sort();
-}
-export async function addSkill(cwd, name, targetRaw, force) {
-    const config = await loadConfig(cwd);
-    let manifest = await loadSkillManifestByName(cwd, name);
-    if (!manifest) {
-        const all = await loadAllSkillManifests(cwd);
-        manifest = all.find((item) => item.name === name) ?? null;
-    }
-    if (!manifest) {
-        throw new Error(`Skill "${name}" not found under .codex/.`);
-    }
-    const diagnostics = [...validateManifest(manifest)];
-    const targets = expandTargets(targetRaw);
-    for (const target of targets) {
-        diagnostics.push(...getAdapter(target).validate(manifest));
-    }
-    failIfErrors(diagnostics);
-    for (const target of targets) {
-        const adapter = getAdapter(target);
-        const outDir = path.join(resolveAgentRoot(cwd, config.agents[target].rootDir), "skills", manifest.name);
-        await adapter.emit(manifest, outDir, force);
-    }
-}
-export async function syncSkills(cwd, targetRaw, force) {
-    const config = await loadConfig(cwd);
-    const manifests = await loadAllSkillManifests(cwd);
-    if (manifests.length === 0) {
-        throw new Error("No skills found under .codex/.");
-    }
-    const targets = expandTargets(targetRaw);
-    for (const manifest of manifests) {
-        const diagnostics = [...validateManifest(manifest)];
-        for (const target of targets) {
-            diagnostics.push(...getAdapter(target).validate(manifest));
-        }
-        failIfErrors(diagnostics);
-    }
-    for (const manifest of manifests) {
-        for (const target of targets) {
-            const outDir = path.join(resolveAgentRoot(cwd, config.agents[target].rootDir), "skills", manifest.name);
-            await getAdapter(target).emit(manifest, outDir, force);
-        }
-    }
-}
 export async function initSkills(cwd, agentsRaw, force) {
     await cleanupLegacyDefaultSkillDir(cwd);
     const baseConfig = await loadConfig(cwd);

package/package.json

@@ -1,6 +1,7 @@
 {
   "name": "cdspec",
-  "version": "0.1.0",
+  "version": "0.1.1",
+  "author": "liyanwei",
   "description": "CDSpec CLI for skill sync and task split/archive workflow",
   "type": "module",
   "bin": {

package/src/cli.ts

@@ -3,12 +3,11 @@ import checkbox from '@inquirer/checkbox'
 import { Command } from 'commander'
 import path from 'node:path'
 import process from 'node:process'
-import { addSkill, initSkills, listSkills, syncSkills } from './skill-core/service.js'
-import { archiveTaskById, splitTasks, updateTask } from './task-core/service.js'
+import { initSkills } from './skill-core/service.js'
 
 const program = new Command()
 
-program.name('cdspec').description('Skill sync + task split/archive workflow CLI').version('0.1.0')
+program.name('cdspec').description('Skill init CLI').version('0.1.0')
 
 program
   .command('init')
@@ -17,71 +16,10 @@ program
   .action(async (options: { agents?: string }) => {
     const selected = options.agents ?? (await askAgentsSelection())
     const files = await initSkills(process.cwd(), selected, true)
-    console.log(`Initialized OpenSpec-style setup for "${selected}".`)
+    console.log(`Initialized setup for "${selected}".`)
     console.log(`Generated files: ${files.map(x => path.relative(process.cwd(), x)).join(', ')}`)
   })
 
-program
-  .command('skill')
-  .description('Skill operations')
-  .addCommand(
-    new Command('list').action(async () => {
-      const names = await listSkills(process.cwd())
-      if (names.length === 0) {
-        console.log('No skill found under .codex/.')
-        return
-      }
-      names.forEach(name => console.log(name))
-    })
-  )
-  .addCommand(
-    new Command('add')
-      .argument('<name>', 'skill folder name under .codex')
-      .option('--target <target>', 'codex|claudecode|iflow|all or comma-separated', 'all')
-      .option('--force', 'overwrite existing output', false)
-      .action(async (name: string, options: { target: string; force: boolean }) => {
-        await addSkill(process.cwd(), name, options.target, options.force)
-        console.log(`Skill "${name}" exported to tool folders for target "${options.target}".`)
-      })
-  )
-  .addCommand(
-    new Command('sync')
-      .option('--target <target>', 'codex|claudecode|iflow|all or comma-separated', 'all')
-      .option('--force', 'overwrite existing output', false)
-      .action(async (options: { target: string; force: boolean }) => {
-        await syncSkills(process.cwd(), options.target, options.force)
-        console.log(`All skills synced to tool folders for target "${options.target}".`)
-      })
-  )
-
-program
-  .command('task')
-  .description('Task split/archive operations')
-  .addCommand(
-    new Command('split')
-      .requiredOption('--from <file>', 'source markdown file')
-      .requiredOption('--title <title>', 'task group title')
-      .action(async (options: { from: string; title: string }) => {
-        const count = await splitTasks(process.cwd(), options.from, options.title)
-        console.log(`Generated ${count} tasks from "${options.from}".`)
-      })
-  )
-  .addCommand(
-    new Command('status')
-      .requiredOption('--id <id>', 'task id')
-      .requiredOption('--to <status>', 'todo|in_progress|done')
-      .action(async (options: { id: string; to: 'todo' | 'in_progress' | 'done' }) => {
-        await updateTask(process.cwd(), options.id, options.to)
-        console.log(`Task "${options.id}" updated to "${options.to}".`)
-      })
-  )
-  .addCommand(
-    new Command('archive').requiredOption('--id <id>', 'task id').action(async (options: { id: string }) => {
-      await archiveTaskById(process.cwd(), options.id)
-      console.log(`Task "${options.id}" archived.`)
-    })
-  )
-
 program.parseAsync(process.argv).catch((error: unknown) => {
   const message = error instanceof Error ? error.message : String(error)
   console.error(message)
@@ -103,3 +41,4 @@ async function askAgentsSelection(): Promise<string> {
   if (values.includes('all')) return 'all'
   return values.join(',')
 }
+

package/src/skill-core/manifest-loader.ts

@@ -18,13 +18,6 @@ export async function loadAllSkillManifests(cwd: string): Promise<SkillManifest[
   return manifests;
 }
 
-export async function loadSkillManifestByName(
-  cwd: string,
-  name: string
-): Promise<SkillManifest | null> {
-  return loadSkillManifest(path.join(cwd, CODEX_DIR, name));
-}
-
 async function loadSkillManifest(skillDir: string): Promise<SkillManifest | null> {
   const skillMdPath = path.join(skillDir, "SKILL.md");
   if (!(await pathExists(skillMdPath))) return null;

package/src/skill-core/service.ts

@@ -3,7 +3,7 @@ import { rm } from "node:fs/promises";
 import { loadConfig } from "../config/loader.js";
 import { resolveAgentRoot } from "../config/path.js";
 import { CDSpecConfig } from "../config/types.js";
-import { loadAllSkillManifests, loadSkillManifestByName } from "./manifest-loader.js";
+import { loadAllSkillManifests } from "./manifest-loader.js";
 import { expandTargets, getAdapter } from "./adapters/index.js";
 import {
   installToolInteractionTemplates,
@@ -17,68 +17,6 @@ import {
 import { SkillManifest } from "./types.js";
 import { validateManifest } from "./validator.js";
 
-export async function listSkills(cwd: string): Promise<string[]> {
-  const manifests = await loadAllSkillManifests(cwd);
-  return manifests.map((manifest) => manifest.name).sort();
-}
-
-export async function addSkill(
-  cwd: string,
-  name: string,
-  targetRaw: string,
-  force: boolean
-): Promise<void> {
-  const config = await loadConfig(cwd);
-  let manifest = await loadSkillManifestByName(cwd, name);
-  if (!manifest) {
-    const all = await loadAllSkillManifests(cwd);
-    manifest = all.find((item) => item.name === name) ?? null;
-  }
-  if (!manifest) {
-    throw new Error(`Skill "${name}" not found under .codex/.`);
-  }
-  const diagnostics = [...validateManifest(manifest)];
-  const targets = expandTargets(targetRaw);
-  for (const target of targets) {
-    diagnostics.push(...getAdapter(target).validate(manifest));
-  }
-  failIfErrors(diagnostics);
-
-  for (const target of targets) {
-    const adapter = getAdapter(target);
-    const outDir = path.join(resolveAgentRoot(cwd, config.agents[target].rootDir), "skills", manifest.name);
-    await adapter.emit(manifest, outDir, force);
-  }
-}
-
-export async function syncSkills(
-  cwd: string,
-  targetRaw: string,
-  force: boolean
-): Promise<void> {
-  const config = await loadConfig(cwd);
-  const manifests = await loadAllSkillManifests(cwd);
-  if (manifests.length === 0) {
-    throw new Error("No skills found under .codex/.");
-  }
-  const targets = expandTargets(targetRaw);
-
-  for (const manifest of manifests) {
-    const diagnostics = [...validateManifest(manifest)];
-    for (const target of targets) {
-      diagnostics.push(...getAdapter(target).validate(manifest));
-    }
-    failIfErrors(diagnostics);
-  }
-
-  for (const manifest of manifests) {
-    for (const target of targets) {
-      const outDir = path.join(resolveAgentRoot(cwd, config.agents[target].rootDir), "skills", manifest.name);
-      await getAdapter(target).emit(manifest, outDir, force);
-    }
-  }
-}
-
 export async function initSkills(
   cwd: string,
   agentsRaw: string,

package/tests/init.test.ts

@@ -0,0 +1,63 @@
+import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { describe, expect, it } from "vitest";
+import { initSkills } from "../src/skill-core/service.js";
+
+describe("init command core flow", () => {
+  it("exports all template skills and creates cd-full-name prompts", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-init-"));
+    await seedTemplateSkill(root, "design-doc");
+    await seedTemplateSkill(root, "frontend-standards");
+    await initSkills(root, "codex", true);
+
+    const skills = await readDirNames(path.join(root, ".codex", "skills"));
+    expect(skills).toEqual(["design-doc", "frontend-standards"]);
+
+    const prompts = await readDirNames(path.join(root, ".codex", "prompts"));
+    expect(prompts).toEqual(["cd-design-doc.md", "cd-frontend-standards.md"]);
+
+    const promptContent = await readFile(
+      path.join(root, ".codex", "prompts", "cd-frontend-standards.md"),
+      "utf8"
+    );
+    expect(promptContent).toContain("skill: frontend-standards");
+  });
+
+  it("overwrites old prompts/skills when force=true", async () => {
+    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-force-"));
+    await seedTemplateSkill(root, "design-doc");
+    await initSkills(root, "codex", true);
+
+    await writeFile(path.join(root, ".codex", "prompts", "old.md"), "old");
+    await writeFile(path.join(root, ".codex", "skills", "old", "SKILL.md"), "x", "utf8").catch(
+      async () => {
+        await mkdir(path.join(root, ".codex", "skills", "old"), { recursive: true });
+        await writeFile(path.join(root, ".codex", "skills", "old", "SKILL.md"), "x", "utf8");
+      }
+    );
+
+    await initSkills(root, "codex", true);
+    const prompts = await readDirNames(path.join(root, ".codex", "prompts"));
+    const skills = await readDirNames(path.join(root, ".codex", "skills"));
+    expect(prompts).toEqual(["cd-design-doc.md"]);
+    expect(skills).toEqual(["design-doc"]);
+  });
+});
+
+async function seedTemplateSkill(root: string, name: string): Promise<void> {
+  const dir = path.join(root, "templates", name);
+  await mkdir(path.join(dir, "agents"), { recursive: true });
+  await writeFile(
+    path.join(dir, "SKILL.md"),
+    ["---", `name: ${name}`, "description: desc", "---", "", `# ${name}`].join("\n"),
+    "utf8"
+  );
+  await writeFile(path.join(dir, "agents", "openai.yaml"), "interface:\n  display_name: x\n");
+}
+
+async function readDirNames(dir: string): Promise<string[]> {
+  const entries = await (await import("node:fs/promises")).readdir(dir, { withFileTypes: true });
+  return entries.map((e) => e.name).sort();
+}
+

package/AGENTS.md

@@ -1,14 +0,0 @@
-# AGENTS instructions
-
-<INSTRUCTIONS>
-## OpenSpec Setup
-Enabled targets: codex
-### Skills
-- design-doc: 管理业务详细设计文档的全生命周期：首次基线、增量 feature 文档、归档合并。适用于首次开发与迭代改造，避免小改动频繁新建基线版本文件，同时保留 feature 变更历史。
-- frontend-standards: 部门级前端开发规范执行技能，覆盖 Vue3 编码规范、工程配置规范、Git 提交规范与前端最佳实践。用于前端需求开发、重构、代码评审、工程初始化与联调前自检；当任务涉及 Vue3/TypeScript 页面与组件实现、样式规范、ESLint/Prettier/Husky/Commitlint 配置时触发。
-- standards-backend: 部门级后端开发规范执行技能，覆盖后端编码规范、数据库设计规范、传统三层架构约束、DDD架构约束、常用设计模式落地与JUC并发编排规范，并内置数据表基线字段与关联表例外规则。用于需求开发、重构、代码评审、建表SQL设计、接口设计、并发优化与联调前自检等场景；当任务涉及 Java 后端实现、SQL/表结构、分层落位、架构选型（三层或DDD）、可扩展性设计（策略/工厂/责任链/适配器/模板/单例）或线程池/CompletableFuture/CountDownLatch/Semaphore/ReentrantLock/Atomic* 等并发处理时触发。
-### Command Bindings
-- cd-design-doc -> design-doc
-- cd-frontend-standards -> frontend-standards
-- cd-standards-backend -> standards-backend
-</INSTRUCTIONS>

package/CLAUDE.md

@@ -1,10 +0,0 @@
-# claudecode OpenSpec-style setup
-
-## Installed skills
-- frontend-develop-standard: Generated from templates/frontend_develop_standard.md
-
-## Commands
-- /opsx:propose -> frontend-develop-standard
-- /opsx:explore -> frontend-develop-standard
-- /opsx:apply -> frontend-develop-standard
-- /opsx:archive -> frontend-develop-standard

package/src/task-core/parser.ts

@@ -1,89 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "node:path";
-import { TaskItem } from "./types.js";
-
-export function splitMarkdownToTasks(
-  markdown: string,
-  sourcePath: string,
-  rootTitle: string
-): TaskItem[] {
-  const normalized = markdown.replace(/\r\n/g, "\n");
-  const lines = normalized.split("\n");
-  const headingStack: string[] = [];
-  const extracted: string[] = [];
-
-  for (const line of lines) {
-    const headingMatch = line.match(/^(#{1,6})\s+(.+?)\s*$/);
-    if (headingMatch) {
-      const level = headingMatch[1].length;
-      const title = headingMatch[2].trim();
-      headingStack.splice(level - 1);
-      headingStack[level - 1] = title;
-      continue;
-    }
-
-    const listMatch = line.match(/^\s*(?:[-*+]|\d+\.)\s+(.+?)\s*$/);
-    if (!listMatch) continue;
-    const item = listMatch[1].trim();
-    const prefix = headingStack.filter(Boolean).join(" / ");
-    extracted.push(prefix ? `${prefix} - ${item}` : item);
-  }
-
-  if (extracted.length === 0) {
-    for (const line of lines) {
-      const headingMatch = line.match(/^#{2,6}\s+(.+?)\s*$/);
-      if (headingMatch) extracted.push(headingMatch[1].trim());
-    }
-  }
-
-  if (extracted.length === 0) {
-    extracted.push(rootTitle);
-  }
-
-  return dedupe(extracted).map((title, idx) =>
-    createTaskItem({
-      sourcePath,
-      title,
-      order: idx + 1
-    })
-  );
-}
-
-function createTaskItem(input: {
-  sourcePath: string;
-  title: string;
-  order: number;
-}): TaskItem {
-  const now = new Date().toISOString();
-  return {
-    id: buildStableId(input.sourcePath, input.title, input.order),
-    title: input.title,
-    status: "todo",
-    source: normalizePath(input.sourcePath),
-    createdAt: now,
-    updatedAt: now
-  };
-}
-
-function buildStableId(sourcePath: string, title: string, order: number): string {
-  const digest = createHash("sha1")
-    .update(`${normalizePath(sourcePath)}::${title}::${order}`)
-    .digest("hex");
-  return digest.slice(0, 10);
-}
-
-function normalizePath(input: string): string {
-  return input.replaceAll("\\", "/").replaceAll(path.sep, "/");
-}
-
-function dedupe(items: string[]): string[] {
-  const seen = new Set<string>();
-  const result: string[] = [];
-  for (const item of items) {
-    if (seen.has(item)) continue;
-    seen.add(item);
-    result.push(item);
-  }
-  return result;
-}
-

package/src/task-core/service.ts

@@ -1,49 +0,0 @@
-import { readFile } from "node:fs/promises";
-import path from "node:path";
-import { pathExists } from "../utils/fs.js";
-import { splitMarkdownToTasks } from "./parser.js";
-import {
-  archiveTask,
-  initTaskWorkspace,
-  refreshArchiveIndex,
-  refreshTaskIndex,
-  saveTask,
-  updateTaskStatus
-} from "./storage.js";
-import { TaskStatus } from "./types.js";
-
-export async function splitTasks(
-  cwd: string,
-  fromFile: string,
-  title: string
-): Promise<number> {
-  const absoluteInput = path.resolve(cwd, fromFile);
-  if (!(await pathExists(absoluteInput))) {
-    throw new Error(`Input file not found: ${fromFile}`);
-  }
-
-  const markdown = await readFile(absoluteInput, "utf8");
-  const tasks = splitMarkdownToTasks(markdown, fromFile, title);
-  await initTaskWorkspace(cwd);
-  for (const task of tasks) {
-    await saveTask(cwd, task);
-  }
-  await refreshTaskIndex(cwd);
-  return tasks.length;
-}
-
-export async function archiveTaskById(cwd: string, id: string): Promise<void> {
-  await archiveTask(cwd, id);
-  await refreshTaskIndex(cwd);
-  await refreshArchiveIndex(cwd);
-}
-
-export async function updateTask(
-  cwd: string,
-  id: string,
-  status: TaskStatus
-): Promise<void> {
-  await updateTaskStatus(cwd, id, status);
-  await refreshTaskIndex(cwd);
-}
-

package/src/task-core/storage.ts

@@ -1,177 +0,0 @@
-import { readFile, rm, writeFile, readdir } from "node:fs/promises";
-import path from "node:path";
-import { ensureDir, pathExists } from "../utils/fs.js";
-import { parseFrontmatter, stringifyFrontmatter } from "../utils/frontmatter.js";
-import { ArchiveRecord, TaskItem, TaskStatus } from "./types.js";
-
-const ROOT_DIR = ".cdspec";
-const TASKS_DIR = "tasks";
-const ARCHIVE_DIR = "archive";
-
-export function taskDir(cwd: string): string {
-  return path.join(cwd, ROOT_DIR, TASKS_DIR);
-}
-
-export function archiveDir(cwd: string): string {
-  return path.join(cwd, ROOT_DIR, ARCHIVE_DIR);
-}
-
-export async function initTaskWorkspace(cwd: string): Promise<void> {
-  await ensureDir(taskDir(cwd));
-  await ensureDir(archiveDir(cwd));
-}
-
-export async function saveTask(cwd: string, task: TaskItem): Promise<void> {
-  await initTaskWorkspace(cwd);
-  const targetFile = path.join(taskDir(cwd), `${task.id}.md`);
-  const body = `# ${task.title}\n\n- status: ${task.status}\n- source: ${task.source}\n`;
-  const content = stringifyFrontmatter(
-    {
-      id: task.id,
-      title: task.title,
-      status: task.status,
-      source: task.source,
-      created_at: task.createdAt,
-      updated_at: task.updatedAt
-    },
-    body
-  );
-  await writeFile(targetFile, content, "utf8");
-}
-
-export async function loadTask(cwd: string, id: string): Promise<TaskItem | null> {
-  const file = path.join(taskDir(cwd), `${id}.md`);
-  if (!(await pathExists(file))) return null;
-  const raw = await readFile(file, "utf8");
-  const parsed = parseFrontmatter(raw);
-  return {
-    id: parsed.attributes.id,
-    title: parsed.attributes.title,
-    status: parseStatus(parsed.attributes.status),
-    source: parsed.attributes.source,
-    createdAt: parsed.attributes.created_at,
-    updatedAt: parsed.attributes.updated_at
-  };
-}
-
-export async function updateTaskStatus(
-  cwd: string,
-  id: string,
-  next: TaskStatus
-): Promise<TaskItem> {
-  const current = await loadTask(cwd, id);
-  if (!current) {
-    throw new Error(`Task "${id}" not found.`);
-  }
-  if (!canTransition(current.status, next)) {
-    throw new Error(`Invalid status transition: ${current.status} -> ${next}.`);
-  }
-  const updated: TaskItem = {
-    ...current,
-    status: next,
-    updatedAt: new Date().toISOString()
-  };
-  await saveTask(cwd, updated);
-  return updated;
-}
-
-export async function archiveTask(cwd: string, id: string): Promise<ArchiveRecord> {
-  const current = await loadTask(cwd, id);
-  if (!current) {
-    throw new Error(`Task "${id}" not found.`);
-  }
-  if (current.status !== "done") {
-    throw new Error(`Task "${id}" must be done before archive.`);
-  }
-
-  const archived: ArchiveRecord = {
-    ...current,
-    archivedAt: new Date().toISOString()
-  };
-  const sourceFile = path.join(taskDir(cwd), `${id}.md`);
-  const archiveFile = path.join(archiveDir(cwd), `${id}.md`);
-  const body = `# ${archived.title}\n\nArchived from ${sourceFile.replaceAll("\\", "/")}.\n`;
-  const content = stringifyFrontmatter(
-    {
-      id: archived.id,
-      title: archived.title,
-      status: archived.status,
-      source: archived.source,
-      created_at: archived.createdAt,
-      updated_at: archived.updatedAt,
-      archived_at: archived.archivedAt
-    },
-    body
-  );
-  await writeFile(archiveFile, content, "utf8");
-  await rm(sourceFile, { force: true });
-  return archived;
-}
-
-export async function refreshTaskIndex(cwd: string): Promise<void> {
-  await initTaskWorkspace(cwd);
-  const tasks = await loadByDir(taskDir(cwd));
-  const grouped = {
-    todo: tasks.filter((task) => task.status === "todo"),
-    in_progress: tasks.filter((task) => task.status === "in_progress"),
-    done: tasks.filter((task) => task.status === "done")
-  };
-  const lines = [
-    "# Task Index",
-    "",
-    "## todo",
-    ...grouped.todo.map((task) => `- [${task.id}] ${task.title}`),
-    "",
-    "## in_progress",
-    ...grouped.in_progress.map((task) => `- [${task.id}] ${task.title}`),
-    "",
-    "## done",
-    ...grouped.done.map((task) => `- [${task.id}] ${task.title}`),
-    ""
-  ];
-  await writeFile(path.join(taskDir(cwd), "index.md"), lines.join("\n"), "utf8");
-}
-
-export async function refreshArchiveIndex(cwd: string): Promise<void> {
-  await initTaskWorkspace(cwd);
-  const records = await loadByDir(archiveDir(cwd));
-  const lines = [
-    "# Archive Index",
-    "",
-    ...records.map((record) => `- [${record.id}] ${record.title}`),
-    ""
-  ];
-  await writeFile(path.join(archiveDir(cwd), "index.md"), lines.join("\n"), "utf8");
-}
-
-async function loadByDir(dirPath: string): Promise<TaskItem[]> {
-  if (!(await pathExists(dirPath))) return [];
-  const entries = await readdir(dirPath, { withFileTypes: true });
-  const result: TaskItem[] = [];
-  for (const entry of entries) {
-    if (!entry.isFile() || !entry.name.endsWith(".md") || entry.name === "index.md") continue;
-    const raw = await readFile(path.join(dirPath, entry.name), "utf8");
-    const parsed = parseFrontmatter(raw);
-    result.push({
-      id: parsed.attributes.id,
-      title: parsed.attributes.title,
-      status: parseStatus(parsed.attributes.status),
-      source: parsed.attributes.source,
-      createdAt: parsed.attributes.created_at,
-      updatedAt: parsed.attributes.updated_at
-    });
-  }
-  return result;
-}
-
-function parseStatus(input: string): TaskStatus {
-  if (input === "todo" || input === "in_progress" || input === "done") return input;
-  return "todo";
-}
-
-function canTransition(current: TaskStatus, next: TaskStatus): boolean {
-  if (current === next) return true;
-  if (current === "todo" && next === "in_progress") return true;
-  if (current === "in_progress" && next === "done") return true;
-  return false;
-}

package/src/task-core/types.ts

@@ -1,15 +0,0 @@
-export type TaskStatus = "todo" | "in_progress" | "done";
-
-export interface TaskItem {
-  id: string;
-  title: string;
-  status: TaskStatus;
-  source: string;
-  createdAt: string;
-  updatedAt: string;
-}
-
-export interface ArchiveRecord extends TaskItem {
-  archivedAt: string;
-}
-

package/tests/skill.test.ts

@@ -1,191 +0,0 @@
-import { mkdtemp, mkdir, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { addSkill, initSkills, listSkills } from "../src/skill-core/service.js";
-
-async function seedSkillRepo(): Promise<string> {
-  const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-skill-"));
-  const skillDir = path.join(root, ".codex", "demo-skill");
-  await mkdir(path.join(skillDir, "agents"), { recursive: true });
-  await mkdir(path.join(skillDir, "references"), { recursive: true });
-
-  await writeFile(
-    path.join(skillDir, "SKILL.md"),
-    [
-      "---",
-      "name: demo-skill",
-      "description: demo description",
-      "---",
-      "",
-      "# Demo Skill",
-      "",
-      "body"
-    ].join("\n"),
-    "utf8"
-  );
-  await writeFile(path.join(skillDir, "agents", "openai.yaml"), "x: 1\n", "utf8");
-  await writeFile(path.join(skillDir, "references", "readme.md"), "ref\n", "utf8");
-  return root;
-}
-
-describe("skill service", () => {
-  it("lists valid skills", async () => {
-    const root = await seedSkillRepo();
-    const names = await listSkills(root);
-    expect(names).toEqual(["demo-skill"]);
-  });
-
-  it("exports skill to all targets", async () => {
-    const root = await seedSkillRepo();
-    await addSkill(root, "demo-skill", "all", false);
-
-    const codexSkill = await readFile(
-      path.join(root, ".codex", "skills", "demo-skill", "SKILL.md"),
-      "utf8"
-    );
-    const claudecodeMeta = await readFile(
-      path.join(root, ".claude", "skills", "demo-skill", "claudecode.skill.json"),
-      "utf8"
-    );
-    const iflowMeta = await readFile(
-      path.join(root, ".iflow", "skills", "demo-skill", "iflow.skill.yaml"),
-      "utf8"
-    );
-
-    expect(codexSkill).toContain("name: demo-skill");
-    expect(claudecodeMeta).toContain('"name": "demo-skill"');
-    expect(iflowMeta).toContain('name: "demo-skill"');
-  });
-
-  it("rejects conflict without force", async () => {
-    const root = await seedSkillRepo();
-    await addSkill(root, "demo-skill", "codex", false);
-    await expect(addSkill(root, "demo-skill", "codex", false)).rejects.toThrow(
-      /Use --force/
-    );
-  });
-
-  it("supports ifow alias", async () => {
-    const root = await seedSkillRepo();
-    await addSkill(root, "demo-skill", "ifow", false);
-    const iflowMeta = await readFile(
-      path.join(root, ".iflow", "skills", "demo-skill", "iflow.skill.yaml"),
-      "utf8"
-    );
-    expect(iflowMeta).toContain('entry: "prompt.md"');
-  });
-
-  it("generates agent config files on init", async () => {
-    const root = await seedSkillRepo();
-    const files = await initSkills(root, "codex,ifow", false);
-    expect(files.some((file) => file.endsWith(path.join(".codex", "AGENTS.md")))).toBe(true);
-    expect(files.some((file) => file.endsWith(path.join(".iflow", "IFLOW.md")))).toBe(true);
-    expect(files.some((file) => file.endsWith(path.join("AGENTS.md")))).toBe(true);
-
-    const agents = await readFile(path.join(root, ".codex", "AGENTS.md"), "utf8");
-    const iflow = await readFile(path.join(root, ".iflow", "IFLOW.md"), "utf8");
-    expect(agents).toContain("demo-skill");
-    expect(iflow).toContain("/cd-demo-skill -> demo-skill");
-    const command = await readFile(path.join(root, ".codex", "prompts", "cd-demo-skill.md"), "utf8");
-    expect(command).toContain("skill: demo-skill");
-  });
-
-  it("creates default skill when .codex is empty", async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-empty-"));
-    const files = await initSkills(root, "codex", false);
-    expect(files.some((file) => file.endsWith(path.join(".codex", "AGENTS.md")))).toBe(true);
-    expect(files.some((file) => file.endsWith(path.join("AGENTS.md")))).toBe(true);
-    const exported = await readFile(
-      path.join(root, ".codex", "skills", "openspec-core", "SKILL.md"),
-      "utf8"
-    );
-    await expect(readFile(path.join(root, ".cdspec", "seed-skills", "openspec-core", "SKILL.md"), "utf8")).rejects.toThrow();
-    await expect(readFile(path.join(root, ".codex", "openspec-core", "SKILL.md"), "utf8")).rejects.toThrow();
-    expect(exported).toContain("OpenSpec Core Skill");
-  });
-
-  it("supports configurable agent output paths", async () => {
-    const root = await seedSkillRepo();
-    await writeFile(
-      path.join(root, "cdspec.config.yaml"),
-      [
-        "commandBindings:",
-        "  - id: plan",
-        "    skill: demo-skill",
-        "    description: Plan workflow",
-        "agents:",
-        "  codex:",
-        "    rootDir: .codex",
-        "    commandsDir: prompts",
-        "    commandFilePattern: custom-{id}.md",
-        "    slashPattern: /custom-{id}",
-        "    guideFile: AGENTS.md",
-        "  claudecode:",
-        "    rootDir: .claude",
-        "    commandsDir: commands/opsx",
-        "    commandFilePattern: \"{id}.md\"",
-        "    slashPattern: /opsx:{id}",
-        "    guideFile: CLAUDE.md",
-        "    guideAtProjectRoot: true",
-        "  iflow:",
-        "    rootDir: .iflow",
-        "    commandsDir: commands",
-        "    commandFilePattern: opsx-{id}.md",
-        "    slashPattern: /opsx-{id}",
-        "    guideFile: IFLOW.md"
-      ].join("\n"),
-      "utf8"
-    );
-
-    await addSkill(root, "demo-skill", "codex", false);
-    const exported = await readFile(path.join(root, ".codex", "skills", "demo-skill", "SKILL.md"), "utf8");
-    expect(exported).toContain("name: demo-skill");
-  });
-
-  it("binds commands to template-derived skill when no .codex skills exist", async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-template-bind-"));
-    await mkdir(path.join(root, "templates"), { recursive: true });
-    await writeFile(
-      path.join(root, "templates", "frontend_develop_standard.md"),
-      "# Frontend Develop Standard\n\nTemplate body",
-      "utf8"
-    );
-    await initSkills(root, "codex", false);
-
-    const exported = await readFile(
-      path.join(root, ".codex", "skills", "frontend-develop-standard", "SKILL.md"),
-      "utf8"
-    );
-    expect(exported).toContain("name: frontend-develop-standard");
-
-    const prompt = await readFile(path.join(root, ".codex", "prompts", "cd-frontend-develop-standard.md"), "utf8");
-    expect(prompt).toContain("skill: frontend-develop-standard");
-  });
-
-  it("prioritizes templates over existing .codex skills for init binding", async () => {
-    const root = await seedSkillRepo();
-    await mkdir(path.join(root, "templates"), { recursive: true });
-    await writeFile(path.join(root, "templates", "my_template.md"), "# My Template\n", "utf8");
-
-    await initSkills(root, "codex", true);
-    const prompt = await readFile(path.join(root, ".codex", "prompts", "cd-my-template.md"), "utf8");
-    expect(prompt).toContain("skill: my-template");
-    const exported = await readFile(path.join(root, ".codex", "skills", "my-template", "SKILL.md"), "utf8");
-    expect(exported).toContain("name: my-template");
-  });
-
-  it("uses full skill name for command ids", async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-fullname-"));
-    await mkdir(path.join(root, "templates", "design-doc", "agents"), { recursive: true });
-    await writeFile(
-      path.join(root, "templates", "design-doc", "SKILL.md"),
-      ["---", "name: design-doc", "description: d", "---", "", "# d"].join("\n"),
-      "utf8"
-    );
-    await writeFile(path.join(root, "templates", "design-doc", "agents", "openai.yaml"), "x: 1\n");
-    await initSkills(root, "codex", false);
-    const prompt = await readFile(path.join(root, ".codex", "prompts", "cd-design-doc.md"), "utf8");
-    expect(prompt).toContain("skill: design-doc");
-  });
-});

package/tests/task.test.ts

@@ -1,55 +0,0 @@
-import { mkdtemp, readFile, writeFile } from "node:fs/promises";
-import os from "node:os";
-import path from "node:path";
-import { describe, expect, it } from "vitest";
-import { archiveTaskById, splitTasks, updateTask } from "../src/task-core/service.js";
-import { loadTask } from "../src/task-core/storage.js";
-
-describe("task workflow", () => {
-  it("splits markdown into tasks and creates index", async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-task-"));
-    const source = path.join(root, "input.md");
-    await writeFile(
-      source,
-      ["# Feature", "", "## Backend", "- API schema", "## Frontend", "- Build page"].join(
-        "\n"
-      ),
-      "utf8"
-    );
-
-    const count = await splitTasks(root, "input.md", "Root Task");
-    expect(count).toBe(2);
-
-    const index = await readFile(path.join(root, ".cdspec", "tasks", "index.md"), "utf8");
-    expect(index).toContain("## todo");
-  });
-
-  it("enforces status transitions and archive done tasks", async () => {
-    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-task-"));
-    const source = path.join(root, "plan.md");
-    await writeFile(source, "- one\n", "utf8");
-    await splitTasks(root, "plan.md", "Task Plan");
-
-    const ids = await extractTaskIds(root);
-    const id = ids[0];
-
-    await expect(archiveTaskById(root, id)).rejects.toThrow(/must be done/);
-
-    await expect(updateTask(root, id, "done")).rejects.toThrow(/Invalid status transition/);
-    await updateTask(root, id, "in_progress");
-    await updateTask(root, id, "done");
-    await archiveTaskById(root, id);
-
-    const task = await loadTask(root, id);
-    expect(task).toBeNull();
-    const archive = await readFile(path.join(root, ".cdspec", "archive", `${id}.md`), "utf8");
-    expect(archive).toContain("archived_at");
-  });
-});
-
-async function extractTaskIds(root: string): Promise<string[]> {
-  const index = await readFile(path.join(root, ".cdspec", "tasks", "index.md"), "utf8");
-  const ids = [...index.matchAll(/\[([a-f0-9]{10})\]/g)].map((match) => match[1]);
-  return ids;
-}
-