cdspec 0.1.0

package/AGENTS.md

@@ -0,0 +1,14 @@
+# 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

@@ -0,0 +1,10 @@
+# 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/README.md

@@ -0,0 +1,55 @@
+# cdspec
+
+CLI for:
+
+- 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
+
+```bash
+npm install
+npm run build
+node dist/cli.js --help
+```
+
+## Commands
+
+```bash
+cdspec init --agents codex,claudecode,iflow
+
+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>
+```
+
+`cdspec init` generates tool-local files:
+
+- `.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`
+
+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
+
+- Skill output: `.{tool}/skills/{skill-name}`
+- Task workspace: `.cdspec/tasks` and `.cdspec/archive`
+
+## Config
+
+`cdspec.config.yaml` controls:
+
+- command -> skill bindings
+- per-agent root directory and command file pattern
+- slash command display pattern

package/cdspec.config.yaml

@@ -0,0 +1,34 @@
+commandBindings:
+  - id: propose
+    skill: openspec-core
+    description: Create a change proposal with scope and impacted specs.
+  - id: explore
+    skill: openspec-core
+    description: Analyze existing specs and produce planned deltas.
+  - id: apply
+    skill: openspec-core
+    description: Implement approved tasks and keep spec updates in sync.
+  - id: archive
+    skill: openspec-core
+    description: Archive completed changes and update baseline specs.
+
+agents:
+  codex:
+    rootDir: ~/.codex
+    commandsDir: prompts
+    commandFilePattern: opsx-{id}.md
+    slashPattern: /opsx-{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

package/dist/cli.js

@@ -0,0 +1,94 @@
+#!/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";
+const program = new Command();
+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")
+    .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(", ")}`);
+});
+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);
+    process.exitCode = 1;
+});
+async function askAgentsSelection() {
+    if (!process.stdin.isTTY)
+        return "all";
+    const values = await checkbox({
+        message: "Select coding agents",
+        choices: [
+            { 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(",");
+}

package/dist/config/default.js

@@ -0,0 +1,48 @@
+export const defaultConfig = {
+    commandBindings: [
+        {
+            id: "propose",
+            skill: "openspec-core",
+            description: "Create a change proposal with scope and impacted specs."
+        },
+        {
+            id: "explore",
+            skill: "openspec-core",
+            description: "Analyze existing specs and produce planned deltas."
+        },
+        {
+            id: "apply",
+            skill: "openspec-core",
+            description: "Implement approved tasks and keep spec updates in sync."
+        },
+        {
+            id: "archive",
+            skill: "openspec-core",
+            description: "Archive completed changes and update baseline specs."
+        }
+    ],
+    agents: {
+        codex: {
+            rootDir: ".codex",
+            commandsDir: "prompts",
+            commandFilePattern: "opsx-{id}.md",
+            slashPattern: "/opsx-{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"
+        }
+    }
+};

package/dist/config/loader.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { readFile } from "node:fs/promises";
+import { parse } from "yaml";
+import { pathExists } from "../utils/fs.js";
+import { defaultConfig } from "./default.js";
+const CONFIG_FILE = "cdspec.config.yaml";
+export async function loadConfig(cwd) {
+    const configPath = path.join(cwd, CONFIG_FILE);
+    if (!(await pathExists(configPath))) {
+        return defaultConfig;
+    }
+    const raw = await readFile(configPath, "utf8");
+    const parsed = parse(raw);
+    if (!parsed)
+        return defaultConfig;
+    const merged = {
+        commandBindings: parsed.commandBindings && parsed.commandBindings.length > 0
+            ? parsed.commandBindings
+            : defaultConfig.commandBindings,
+        agents: {
+            codex: { ...defaultConfig.agents.codex, ...(parsed.agents?.codex || {}) },
+            claudecode: {
+                ...defaultConfig.agents.claudecode,
+                ...(parsed.agents?.claudecode || {})
+            },
+            iflow: { ...defaultConfig.agents.iflow, ...(parsed.agents?.iflow || {}) }
+        }
+    };
+    return merged;
+}

package/dist/config/path.js

@@ -0,0 +1,11 @@
+import os from "node:os";
+import path from "node:path";
+export function resolveAgentRoot(cwd, rootDir) {
+    if (rootDir.startsWith("~/") || rootDir.startsWith("~\\")) {
+        return path.join(os.homedir(), rootDir.slice(2));
+    }
+    if (path.win32.isAbsolute(rootDir) || path.posix.isAbsolute(rootDir)) {
+        return path.normalize(rootDir);
+    }
+    return path.join(cwd, rootDir);
+}

package/dist/config/types.js

@@ -0,0 +1 @@
+export {};

package/dist/skill-core/adapters/claudecode-adapter.js

@@ -0,0 +1,35 @@
+import path from "node:path";
+import { emptyDir, pathExists } from "../../utils/fs.js";
+import { emitWithLayout } from "./shared.js";
+export class ClaudeCodeAdapter {
+    target = "claudecode";
+    validate(manifest) {
+        const diagnostics = [];
+        if (!manifest.name) {
+            diagnostics.push({ level: "error", message: "[claudecode] name is required." });
+        }
+        return diagnostics;
+    }
+    async emit(manifest, outDir, force) {
+        if ((await pathExists(outDir)) && !force) {
+            throw new Error(`Target already exists for skill "${manifest.name}" at ${outDir}. Use --force to overwrite.`);
+        }
+        if (force) {
+            await emptyDir(outDir);
+        }
+        const meta = {
+            name: manifest.name,
+            description: manifest.description,
+            entry: "SKILL.md"
+        };
+        await emitWithLayout(manifest, outDir, true, [
+            {
+                relativePath: "claudecode.skill.json",
+                content: `${JSON.stringify(meta, null, 2)}\n`
+            }
+        ]);
+    }
+}
+export function claudecodeSkillPath(baseOutDir, skillName) {
+    return path.join(baseOutDir, "claudecode", skillName);
+}

package/dist/skill-core/adapters/codex-adapter.js

@@ -0,0 +1,28 @@
+import path from "node:path";
+import { emptyDir, pathExists } from "../../utils/fs.js";
+import { emitWithLayout } from "./shared.js";
+export class CodexAdapter {
+    target = "codex";
+    validate(manifest) {
+        const diagnostics = [];
+        if (!manifest.description) {
+            diagnostics.push({
+                level: "error",
+                message: `[codex] ${manifest.name}: description is required.`
+            });
+        }
+        return diagnostics;
+    }
+    async emit(manifest, outDir, force) {
+        if ((await pathExists(outDir)) && !force) {
+            throw new Error(`Target already exists for skill "${manifest.name}" at ${outDir}. Use --force to overwrite.`);
+        }
+        if (force) {
+            await emptyDir(outDir);
+        }
+        await emitWithLayout(manifest, outDir, true, []);
+    }
+}
+export function codexSkillPath(baseOutDir, skillName) {
+    return path.join(baseOutDir, "codex", skillName);
+}

package/dist/skill-core/adapters/iflow-adapter.js

@@ -0,0 +1,39 @@
+import path from "node:path";
+import { emptyDir, pathExists } from "../../utils/fs.js";
+import { emitWithLayout } from "./shared.js";
+export class IFlowAdapter {
+    target = "iflow";
+    validate(manifest) {
+        const diagnostics = [];
+        if (!manifest.description) {
+            diagnostics.push({
+                level: "warning",
+                message: `[iflow] ${manifest.name}: description is empty.`
+            });
+        }
+        return diagnostics;
+    }
+    async emit(manifest, outDir, force) {
+        if ((await pathExists(outDir)) && !force) {
+            throw new Error(`Target already exists for skill "${manifest.name}" at ${outDir}. Use --force to overwrite.`);
+        }
+        if (force) {
+            await emptyDir(outDir);
+        }
+        const skillYaml = [
+            `name: "${manifest.name}"`,
+            `description: "${manifest.description.replace(/"/g, '\\"')}"`,
+            'entry: "prompt.md"'
+        ].join("\n");
+        await emitWithLayout(manifest, outDir, false, [
+            {
+                relativePath: "prompt.md",
+                content: `# ${manifest.name}\n\n${manifest.body}\n`
+            },
+            { relativePath: "iflow.skill.yaml", content: `${skillYaml}\n` }
+        ]);
+    }
+}
+export function iflowSkillPath(baseOutDir, skillName) {
+    return path.join(baseOutDir, "iflow", skillName);
+}

package/dist/skill-core/adapters/index.js

@@ -0,0 +1,34 @@
+import { ClaudeCodeAdapter } from "./claudecode-adapter.js";
+import { CodexAdapter } from "./codex-adapter.js";
+import { IFlowAdapter } from "./iflow-adapter.js";
+const adapters = {
+    codex: new CodexAdapter(),
+    claudecode: new ClaudeCodeAdapter(),
+    iflow: new IFlowAdapter()
+};
+export function getAdapter(target) {
+    return adapters[target];
+}
+export function expandTargets(raw) {
+    const value = raw.trim().toLowerCase();
+    if (value === "all")
+        return ["codex", "claudecode", "iflow"];
+    const parts = value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean)
+        .map(normalizeTargetAlias);
+    if (parts.length === 0) {
+        throw new Error(`Unknown target "${raw}". Use codex|claudecode|iflow|all.`);
+    }
+    const invalid = parts.filter((item) => item !== "codex" && item !== "claudecode" && item !== "iflow");
+    if (invalid.length > 0) {
+        throw new Error(`Unknown target "${invalid[0]}". Use codex|claudecode|iflow|all.`);
+    }
+    return Array.from(new Set(parts));
+}
+function normalizeTargetAlias(value) {
+    if (value === "ifow")
+        return "iflow";
+    return value;
+}

package/dist/skill-core/adapters/shared.js

@@ -0,0 +1,36 @@
+import { copyFile, readFile, readdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { ensureDir, pathExists } from "../../utils/fs.js";
+export async function emitWithLayout(manifest, outDir, includeOriginalSkillMd, generatedFiles) {
+    await ensureDir(outDir);
+    if (includeOriginalSkillMd) {
+        const srcSkillMd = path.join(manifest.sourcePath, "SKILL.md");
+        await copyFile(srcSkillMd, path.join(outDir, "SKILL.md"));
+    }
+    for (const file of generatedFiles) {
+        const targetFile = path.join(outDir, file.relativePath);
+        await ensureDir(path.dirname(targetFile));
+        await writeFile(targetFile, file.content, "utf8");
+    }
+    const folders = ["agents", "references", "scripts", "assets"];
+    for (const folder of folders) {
+        const sourceFolder = path.join(manifest.sourcePath, folder);
+        if (!(await pathExists(sourceFolder)))
+            continue;
+        await copyFolder(sourceFolder, path.join(outDir, folder));
+    }
+}
+async function copyFolder(srcDir, dstDir) {
+    await ensureDir(dstDir);
+    const entries = await readdir(srcDir, { withFileTypes: true });
+    for (const entry of entries) {
+        const src = path.join(srcDir, entry.name);
+        const dst = path.join(dstDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyFolder(src, dst);
+            continue;
+        }
+        const data = await readFile(src);
+        await writeFile(dst, data);
+    }
+}

package/dist/skill-core/agent-config.js

@@ -0,0 +1,40 @@
+import { basename, join } from "node:path";
+import { writeFile } from "node:fs/promises";
+import { ensureDir } from "../utils/fs.js";
+const CONFIG_FILE_BY_TARGET = {
+    codex: "AGENTS.md",
+    claudecode: "CLAUDE.md",
+    iflow: "IFLOW.md"
+};
+export async function writeAgentConfig(cwd, target, skills) {
+    await ensureDir(cwd);
+    const filename = CONFIG_FILE_BY_TARGET[target];
+    const filePath = join(cwd, filename);
+    const content = renderConfig(target, skills);
+    await writeFile(filePath, content, "utf8");
+    return filePath;
+}
+function renderConfig(target, skills) {
+    const title = `# ${filenameForTarget(target)} instructions`;
+    const lines = [title, "", "<INSTRUCTIONS>", "## Skills"];
+    lines.push("A skill is a local capability package. The list below is generated by `cdspec init`.");
+    lines.push("### Available skills");
+    if (skills.length === 0) {
+        lines.push("- (none)");
+    }
+    else {
+        for (const skill of skills) {
+            const desc = skill.description || "No description.";
+            lines.push(`- ${skill.name}: ${desc} (file: skills/${target}/${skill.name}/SKILL.md)`);
+        }
+    }
+    lines.push("### How to use");
+    lines.push("- Mention the skill name in your request, or use `/use <skill-name>`.");
+    lines.push("- In Codex, `$<skill-name>` is also supported.");
+    lines.push("- Skills are project-local and loaded from the generated `skills/` folder.");
+    lines.push("</INSTRUCTIONS>", "");
+    return lines.join("\n");
+}
+function filenameForTarget(target) {
+    return basename(CONFIG_FILE_BY_TARGET[target], ".md").toUpperCase();
+}

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

@@ -0,0 +1,63 @@
+import { readdir, readFile } from "node:fs/promises";
+import path from "node:path";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+import { listDirs, pathExists } from "../utils/fs.js";
+const CODEX_DIR = ".codex";
+export async function loadAllSkillManifests(cwd) {
+    const sourceRoot = path.join(cwd, CODEX_DIR);
+    const skillDirs = await listDirs(sourceRoot);
+    const manifests = [];
+    for (const dirName of skillDirs) {
+        const fullPath = path.join(sourceRoot, dirName);
+        const manifest = await loadSkillManifest(fullPath);
+        if (manifest)
+            manifests.push(manifest);
+    }
+    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)))
+        return null;
+    const content = await readFile(skillMdPath, "utf8");
+    const parsed = parseFrontmatter(content);
+    const frontName = parsed.attributes.name?.trim();
+    const frontDescription = parsed.attributes.description?.trim();
+    const displayName = frontName || path.basename(skillDir);
+    const agents = await collectRelativeFiles(path.join(skillDir, "agents"), "agents");
+    const resources = await collectRelativeFiles(path.join(skillDir, "references"), "references");
+    const scripts = await collectRelativeFiles(path.join(skillDir, "scripts"), "scripts");
+    const assets = await collectRelativeFiles(path.join(skillDir, "assets"), "assets");
+    return {
+        name: displayName,
+        description: frontDescription || "",
+        body: parsed.body.trim(),
+        agents,
+        resources: [...resources, ...scripts, ...assets],
+        sourcePath: skillDir
+    };
+}
+async function collectRelativeFiles(dirPath, prefix) {
+    if (!(await pathExists(dirPath)))
+        return [];
+    const result = [];
+    await walk(dirPath, (absolutePath) => {
+        const relative = path.relative(path.dirname(dirPath), absolutePath);
+        result.push(relative.replaceAll("\\", "/").replace(`${prefix}/./`, `${prefix}/`));
+    });
+    return result;
+}
+async function walk(dirPath, onFile) {
+    const entries = await readdir(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+        const absolute = path.join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            await walk(absolute, onFile);
+            continue;
+        }
+        onFile(absolute);
+    }
+}