cdspec 0.1.0 → 0.1.3

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/src/types/yaml.d.ts

@@ -1,4 +0,0 @@
-declare module "yaml" {
-  export function parse(input: string): unknown;
-}
-

package/src/utils/frontmatter.ts

@@ -1,55 +0,0 @@
-export interface FrontmatterResult {
-  attributes: Record<string, string>;
-  body: string;
-}
-
-export function parseFrontmatter(content: string): FrontmatterResult {
-  const normalized = content.replace(/^\uFEFF/, "").replace(/\r\n/g, "\n");
-  if (!normalized.startsWith("---\n")) {
-    return { attributes: {}, body: normalized };
-  }
-
-  const endIndex = normalized.indexOf("\n---\n", 4);
-  if (endIndex === -1) {
-    return { attributes: {}, body: normalized };
-  }
-
-  const header = normalized.slice(4, endIndex);
-  const body = normalized.slice(endIndex + 5);
-  const attributes: Record<string, string> = {};
-
-  for (const rawLine of header.split("\n")) {
-    const line = rawLine.trim();
-    if (!line || line.startsWith("#")) continue;
-    const idx = line.indexOf(":");
-    if (idx <= 0) continue;
-
-    const key = line.slice(0, idx).trim();
-    let value = line.slice(idx + 1).trim();
-    value = stripQuotes(value);
-    attributes[key] = value;
-  }
-
-  return { attributes, body };
-}
-
-export function stringifyFrontmatter(
-  attributes: Record<string, string>,
-  body: string
-): string {
-  const lines = Object.entries(attributes).map(([key, value]) => {
-    const escaped = value.replace(/"/g, '\\"');
-    return `${key}: "${escaped}"`;
-  });
-  return `---\n${lines.join("\n")}\n---\n\n${body.trimEnd()}\n`;
-}
-
-function stripQuotes(value: string): string {
-  if (
-    (value.startsWith('"') && value.endsWith('"')) ||
-    (value.startsWith("'") && value.endsWith("'"))
-  ) {
-    return value.slice(1, -1);
-  }
-  return value;
-}

package/src/utils/fs.ts

@@ -1,41 +0,0 @@
-import { mkdir, readdir, rm, stat, copyFile } from "node:fs/promises";
-import path from "node:path";
-
-export async function ensureDir(dirPath: string): Promise<void> {
-  await mkdir(dirPath, { recursive: true });
-}
-
-export async function pathExists(target: string): Promise<boolean> {
-  try {
-    await stat(target);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-export async function emptyDir(dirPath: string): Promise<void> {
-  await rm(dirPath, { recursive: true, force: true });
-  await mkdir(dirPath, { recursive: true });
-}
-
-export async function copyDir(srcDir: string, dstDir: string): Promise<void> {
-  await ensureDir(dstDir);
-  const entries = await readdir(srcDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const srcPath = path.join(srcDir, entry.name);
-    const dstPath = path.join(dstDir, entry.name);
-    if (entry.isDirectory()) {
-      await copyDir(srcPath, dstPath);
-      continue;
-    }
-    await copyFile(srcPath, dstPath);
-  }
-}
-
-export async function listDirs(dirPath: string): Promise<string[]> {
-  if (!(await pathExists(dirPath))) return [];
-  const entries = await readdir(dirPath, { withFileTypes: true });
-  return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-}
-

package/templates/frontend-develop-standard/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "Frontend Develop Standard"
-  short_description: "Generated from templates/frontend_develop_standard.md"
-  default_prompt: "Use $frontend-develop-standard to follow this template skill."

package/templates/standards-backend/agents/openai.yaml

@@ -1,4 +0,0 @@
-interface:
-  display_name: "后端开发规范指南"
-  short_description: "统一后端、数据库、架构、设计模式与JUC并发的执行技能"
-  default_prompt: "Use $department-backend-standards to implement backend changes with department standards for coding, DB design, layered or DDD architecture, design patterns, and JUC concurrency."

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");
-  });
-});