cdspec 0.1.1 → 0.1.3

package/dist/task-core/parser.js

@@ -1,70 +0,0 @@
-import { createHash } from "node:crypto";
-import path from "node:path";
-export function splitMarkdownToTasks(markdown, sourcePath, rootTitle) {
-    const normalized = markdown.replace(/\r\n/g, "\n");
-    const lines = normalized.split("\n");
-    const headingStack = [];
-    const extracted = [];
-    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) {
-    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, title, order) {
-    const digest = createHash("sha1")
-        .update(`${normalizePath(sourcePath)}::${title}::${order}`)
-        .digest("hex");
-    return digest.slice(0, 10);
-}
-function normalizePath(input) {
-    return input.replaceAll("\\", "/").replaceAll(path.sep, "/");
-}
-function dedupe(items) {
-    const seen = new Set();
-    const result = [];
-    for (const item of items) {
-        if (seen.has(item))
-            continue;
-        seen.add(item);
-        result.push(item);
-    }
-    return result;
-}

package/dist/task-core/service.js

@@ -1,28 +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";
-export async function splitTasks(cwd, fromFile, title) {
-    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, id) {
-    await archiveTask(cwd, id);
-    await refreshTaskIndex(cwd);
-    await refreshArchiveIndex(cwd);
-}
-export async function updateTask(cwd, id, status) {
-    await updateTaskStatus(cwd, id, status);
-    await refreshTaskIndex(cwd);
-}

package/dist/task-core/storage.js

@@ -1,159 +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";
-const ROOT_DIR = ".cdspec";
-const TASKS_DIR = "tasks";
-const ARCHIVE_DIR = "archive";
-export function taskDir(cwd) {
-    return path.join(cwd, ROOT_DIR, TASKS_DIR);
-}
-export function archiveDir(cwd) {
-    return path.join(cwd, ROOT_DIR, ARCHIVE_DIR);
-}
-export async function initTaskWorkspace(cwd) {
-    await ensureDir(taskDir(cwd));
-    await ensureDir(archiveDir(cwd));
-}
-export async function saveTask(cwd, task) {
-    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, id) {
-    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, id, next) {
-    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 = {
-        ...current,
-        status: next,
-        updatedAt: new Date().toISOString()
-    };
-    await saveTask(cwd, updated);
-    return updated;
-}
-export async function archiveTask(cwd, id) {
-    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 = {
-        ...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) {
-    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) {
-    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) {
-    if (!(await pathExists(dirPath)))
-        return [];
-    const entries = await readdir(dirPath, { withFileTypes: true });
-    const result = [];
-    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) {
-    if (input === "todo" || input === "in_progress" || input === "done")
-        return input;
-    return "todo";
-}
-function canTransition(current, next) {
-    if (current === next)
-        return true;
-    if (current === "todo" && next === "in_progress")
-        return true;
-    if (current === "in_progress" && next === "done")
-        return true;
-    return false;
-}

package/dist/task-core/types.js

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

package/src/cli.ts

@@ -1,44 +0,0 @@
-#!/usr/bin/env node
-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
-  .command('init')
-  .description('Initialize skills for selected coding agents')
-  .option('--agents <agents>', 'codex|claudecode|iflow|all or comma-separated')
-  .action(async (options: { agents?: string }) => {
-    const selected = options.agents ?? (await askAgentsSelection())
-    const files = await initSkills(process.cwd(), selected, true)
-    console.log(`Initialized setup for "${selected}".`)
-    console.log(`Generated files: ${files.map(x => path.relative(process.cwd(), x)).join(', ')}`)
-  })
-
-program.parseAsync(process.argv).catch((error: unknown) => {
-  const message = error instanceof Error ? error.message : String(error)
-  console.error(message)
-  process.exitCode = 1
-})
-
-async function askAgentsSelection(): Promise<string> {
-  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/src/config/default.ts

@@ -1,51 +0,0 @@
-import { CDSpecConfig } from "./types.js";
-
-export const defaultConfig: CDSpecConfig = {
-  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/src/config/loader.ts

@@ -1,37 +0,0 @@
-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";
-import { CDSpecConfig } from "./types.js";
-
-const CONFIG_FILE = "cdspec.config.yaml";
-
-export async function loadConfig(cwd: string): Promise<CDSpecConfig> {
-  const configPath = path.join(cwd, CONFIG_FILE);
-  if (!(await pathExists(configPath))) {
-    return defaultConfig;
-  }
-
-  const raw = await readFile(configPath, "utf8");
-  const parsed = parse(raw) as Partial<CDSpecConfig> | null;
-  if (!parsed) return defaultConfig;
-
-  const merged: CDSpecConfig = {
-    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/src/config/path.ts

@@ -1,13 +0,0 @@
-import os from "node:os";
-import path from "node:path";
-
-export function resolveAgentRoot(cwd: string, rootDir: string): string {
-  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/src/config/types.ts

@@ -1,22 +0,0 @@
-import { Target } from "../skill-core/types.js";
-
-export interface CommandBinding {
-  id: string;
-  skill: string;
-  description: string;
-}
-
-export interface AgentConfig {
-  rootDir: string;
-  commandsDir: string;
-  commandFilePattern: string;
-  slashPattern: string;
-  guideFile: string;
-  guideAtProjectRoot?: boolean;
-}
-
-export interface CDSpecConfig {
-  commandBindings: CommandBinding[];
-  agents: Record<Target, AgentConfig>;
-}
-

package/src/skill-core/adapters/claudecode-adapter.ts

@@ -1,45 +0,0 @@
-import path from "node:path";
-import { emptyDir, pathExists } from "../../utils/fs.js";
-import { Diagnostic, SkillManifest, TargetAdapter } from "../types.js";
-import { emitWithLayout } from "./shared.js";
-
-export class ClaudeCodeAdapter implements TargetAdapter {
-  target = "claudecode" as const;
-
-  validate(manifest: SkillManifest): Diagnostic[] {
-    const diagnostics: Diagnostic[] = [];
-    if (!manifest.name) {
-      diagnostics.push({ level: "error", message: "[claudecode] name is required." });
-    }
-    return diagnostics;
-  }
-
-  async emit(manifest: SkillManifest, outDir: string, force: boolean): Promise<void> {
-    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: string, skillName: string): string {
-  return path.join(baseOutDir, "claudecode", skillName);
-}
-

package/src/skill-core/adapters/codex-adapter.ts

@@ -1,36 +0,0 @@
-import path from "node:path";
-import { emptyDir, pathExists } from "../../utils/fs.js";
-import { Diagnostic, SkillManifest, TargetAdapter } from "../types.js";
-import { emitWithLayout } from "./shared.js";
-
-export class CodexAdapter implements TargetAdapter {
-  target = "codex" as const;
-
-  validate(manifest: SkillManifest): Diagnostic[] {
-    const diagnostics: Diagnostic[] = [];
-    if (!manifest.description) {
-      diagnostics.push({
-        level: "error",
-        message: `[codex] ${manifest.name}: description is required.`
-      });
-    }
-    return diagnostics;
-  }
-
-  async emit(manifest: SkillManifest, outDir: string, force: boolean): Promise<void> {
-    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: string, skillName: string): string {
-  return path.join(baseOutDir, "codex", skillName);
-}
-

package/src/skill-core/adapters/iflow-adapter.ts

@@ -1,49 +0,0 @@
-import path from "node:path";
-import { emptyDir, pathExists } from "../../utils/fs.js";
-import { Diagnostic, SkillManifest, TargetAdapter } from "../types.js";
-import { emitWithLayout } from "./shared.js";
-
-export class IFlowAdapter implements TargetAdapter {
-  target = "iflow" as const;
-
-  validate(manifest: SkillManifest): Diagnostic[] {
-    const diagnostics: Diagnostic[] = [];
-    if (!manifest.description) {
-      diagnostics.push({
-        level: "warning",
-        message: `[iflow] ${manifest.name}: description is empty.`
-      });
-    }
-    return diagnostics;
-  }
-
-  async emit(manifest: SkillManifest, outDir: string, force: boolean): Promise<void> {
-    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: string, skillName: string): string {
-  return path.join(baseOutDir, "iflow", skillName);
-}
-

package/src/skill-core/adapters/index.ts

@@ -1,39 +0,0 @@
-import { Target, TargetAdapter } from "../types.js";
-import { ClaudeCodeAdapter } from "./claudecode-adapter.js";
-import { CodexAdapter } from "./codex-adapter.js";
-import { IFlowAdapter } from "./iflow-adapter.js";
-
-const adapters: Record<Target, TargetAdapter> = {
-  codex: new CodexAdapter(),
-  claudecode: new ClaudeCodeAdapter(),
-  iflow: new IFlowAdapter()
-};
-
-export function getAdapter(target: Target): TargetAdapter {
-  return adapters[target];
-}
-
-export function expandTargets(raw: string): Target[] {
-  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)) as Target[];
-}
-
-function normalizeTargetAlias(value: string): string {
-  if (value === "ifow") return "iflow";
-  return value;
-}

package/src/skill-core/adapters/shared.ts

@@ -1,45 +0,0 @@
-import { copyFile, readFile, readdir, writeFile } from "node:fs/promises";
-import path from "node:path";
-import { ensureDir, pathExists } from "../../utils/fs.js";
-import { SkillManifest } from "../types.js";
-
-export async function emitWithLayout(
-  manifest: SkillManifest,
-  outDir: string,
-  includeOriginalSkillMd: boolean,
-  generatedFiles: Array<{ relativePath: string; content: string }>
-): Promise<void> {
-  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: string, dstDir: string): Promise<void> {
-  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);
-  }
-}