cdspec 0.1.0

package/dist/skill-core/scaffold.js

@@ -0,0 +1,169 @@
+import { mkdtemp, readdir, readFile, rm, writeFile } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { parseFrontmatter } from "../utils/frontmatter.js";
+import { ensureDir, listDirs, pathExists } from "../utils/fs.js";
+const DEFAULT_SKILL_NAME = "openspec-core";
+const BUILTIN_TEMPLATE_DIR = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../../templates/default-skill");
+export async function cleanupLegacyDefaultSkillDir(cwd) {
+    await rm(path.join(cwd, ".codex", DEFAULT_SKILL_NAME), { recursive: true, force: true });
+    await rm(path.join(cwd, ".cdspec", "seed-skills"), { recursive: true, force: true });
+}
+export async function loadDefaultSkillManifest(cwd) {
+    const projectTemplateManifests = await loadProjectTemplateManifests(cwd);
+    if (projectTemplateManifests.length > 0)
+        return projectTemplateManifests[0];
+    if (await pathExists(path.join(BUILTIN_TEMPLATE_DIR, "SKILL.md"))) {
+        return buildManifestFromDir(BUILTIN_TEMPLATE_DIR);
+    }
+    const tempDir = await buildFallbackTemplateInTemp();
+    return buildManifestFromDir(tempDir);
+}
+export async function loadProjectTemplateManifests(cwd) {
+    return loadFromProjectTemplates(path.join(cwd, "templates"));
+}
+async function buildManifestFromDir(skillDir) {
+    const raw = await readFile(path.join(skillDir, "SKILL.md"), "utf8");
+    const parsed = parseFrontmatter(raw);
+    const name = parsed.attributes.name?.trim() || DEFAULT_SKILL_NAME;
+    const description = parsed.attributes.description?.trim() || "OpenSpec default skill";
+    const agents = await collectRelativeFiles(path.join(skillDir, "agents"));
+    const references = await collectRelativeFiles(path.join(skillDir, "references"));
+    const scripts = await collectRelativeFiles(path.join(skillDir, "scripts"));
+    const assets = await collectRelativeFiles(path.join(skillDir, "assets"));
+    return {
+        name,
+        description,
+        body: parsed.body.trim(),
+        agents,
+        resources: [...references, ...scripts, ...assets],
+        sourcePath: skillDir
+    };
+}
+async function collectRelativeFiles(dirPath) {
+    if (!(await pathExists(dirPath)))
+        return [];
+    const base = path.dirname(dirPath);
+    const result = [];
+    const dirs = [dirPath];
+    while (dirs.length > 0) {
+        const current = dirs.pop();
+        const children = await listDirs(current);
+        for (const child of children) {
+            dirs.push(path.join(current, child));
+        }
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isFile())
+                continue;
+            const fullPath = path.join(current, entry.name);
+            result.push(path.relative(base, fullPath).replaceAll("\\", "/"));
+        }
+    }
+    return result;
+}
+async function buildFallbackTemplateInTemp() {
+    const root = await mkdtemp(path.join(os.tmpdir(), "cdspec-skill-"));
+    await ensureDir(path.join(root, "agents"));
+    await ensureDir(path.join(root, "references"));
+    const skillMd = [
+        "---",
+        "name: openspec-core",
+        "description: OpenSpec-style change workflow skill. Use for proposing, exploring, applying, and archiving spec-driven changes.",
+        "---",
+        "",
+        "# OpenSpec Core Skill",
+        "",
+        "1. /opsx-propose",
+        "2. /opsx-explore",
+        "3. /opsx-apply",
+        "4. /opsx-archive"
+    ].join("\n");
+    const openaiYaml = [
+        "interface:",
+        '  display_name: "OpenSpec Core"',
+        '  short_description: "Spec-driven change workflow with propose/explore/apply/archive"',
+        '  default_prompt: "Use $openspec-core to run OpenSpec-style workflows in this repository."'
+    ].join("\n");
+    await writeFile(path.join(root, "SKILL.md"), `${skillMd}\n`, "utf8");
+    await writeFile(path.join(root, "agents", "openai.yaml"), `${openaiYaml}\n`, "utf8");
+    await writeFile(path.join(root, "references", "project_notes.md"), "# OpenSpec Workflow Notes\n");
+    return root;
+}
+async function loadFromProjectTemplates(templateRoot) {
+    if (!(await pathExists(templateRoot)))
+        return [];
+    const manifests = [];
+    const childDirs = await listDirs(templateRoot);
+    for (const child of childDirs) {
+        const full = path.join(templateRoot, child);
+        if (await pathExists(path.join(full, "SKILL.md"))) {
+            manifests.push(await buildManifestFromDir(full));
+        }
+    }
+    if (manifests.length > 0)
+        return manifests;
+    const markdownFiles = await collectMarkdownFiles(templateRoot);
+    for (const selected of markdownFiles.sort()) {
+        manifests.push(await buildManifestFromMarkdown(templateRoot, selected));
+    }
+    return manifests;
+}
+async function buildManifestFromMarkdown(templateRoot, selected) {
+    const raw = await readFile(selected, "utf8");
+    const parsed = parseFrontmatter(raw);
+    const baseName = path.basename(selected, path.extname(selected));
+    const skillName = normalizeSkillName(parsed.attributes.name || baseName);
+    const description = parsed.attributes.description ||
+        `Generated from templates/${path.relative(templateRoot, selected).replaceAll("\\", "/")}`;
+    const body = parsed.body.trim() || raw.trim();
+    const tmp = await mkdtemp(path.join(os.tmpdir(), "cdspec-template-"));
+    await ensureDir(path.join(tmp, "agents"));
+    await ensureDir(path.join(tmp, "references"));
+    const skillMd = ["---", `name: ${skillName}`, `description: ${description}`, "---", "", body].join("\n");
+    const openaiYaml = [
+        "interface:",
+        `  display_name: "${humanizeName(skillName)}"`,
+        `  short_description: "${escapeYaml(description)}"`,
+        `  default_prompt: "Use $${skillName} to follow this template skill."`
+    ].join("\n");
+    await writeFile(path.join(tmp, "SKILL.md"), `${skillMd}\n`, "utf8");
+    await writeFile(path.join(tmp, "agents", "openai.yaml"), `${openaiYaml}\n`, "utf8");
+    await writeFile(path.join(tmp, "references", path.basename(selected)), raw, "utf8");
+    return buildManifestFromDir(tmp);
+}
+async function collectMarkdownFiles(root) {
+    const files = [];
+    const queue = [root];
+    while (queue.length > 0) {
+        const current = queue.pop();
+        const dirs = await listDirs(current);
+        for (const dir of dirs) {
+            queue.push(path.join(current, dir));
+        }
+        const entries = await readdir(current, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
+                files.push(path.join(current, entry.name));
+            }
+        }
+    }
+    return files;
+}
+function normalizeSkillName(input) {
+    return input
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "") || DEFAULT_SKILL_NAME;
+}
+function humanizeName(input) {
+    return input
+        .split("-")
+        .filter(Boolean)
+        .map((part) => part[0].toUpperCase() + part.slice(1))
+        .join(" ");
+}
+function escapeYaml(value) {
+    return value.replace(/"/g, '\\"');
+}

package/dist/skill-core/service.js

@@ -0,0 +1,156 @@
+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 { 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);
+    const projectTemplateManifests = await loadProjectTemplateManifests(cwd);
+    let manifests = projectTemplateManifests.length > 0
+        ? projectTemplateManifests
+        : await loadAllSkillManifests(cwd);
+    if (manifests.length === 0)
+        manifests = [await loadDefaultSkillManifest(cwd)];
+    const config = buildInitConfig(baseConfig, manifests);
+    const targets = expandTargets(agentsRaw);
+    if (force) {
+        for (const target of targets) {
+            const root = resolveAgentRoot(cwd, config.agents[target].rootDir);
+            await rm(path.join(root, "skills"), {
+                recursive: true,
+                force: true
+            });
+            await rm(path.join(root, config.agents[target].commandsDir), {
+                recursive: true,
+                force: true
+            });
+            const guide = config.agents[target].guideAtProjectRoot
+                ? path.join(cwd, config.agents[target].guideFile)
+                : path.join(root, config.agents[target].guideFile);
+            await rm(guide, { force: true });
+        }
+    }
+    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);
+        }
+    }
+    const files = [];
+    for (const target of targets) {
+        files.push(...(await installToolInteractionTemplates(cwd, target, manifests, config)));
+    }
+    files.push(await writeSharedAgentsStub(cwd, targets, manifests, config));
+    return files;
+}
+function buildInitConfig(config, manifests) {
+    const available = new Set(manifests.map((item) => item.name));
+    const skillDrivenBindings = buildSkillDrivenBindings(manifests);
+    return {
+        ...config,
+        commandBindings: skillDrivenBindings.length > 0
+            ? skillDrivenBindings
+            : config.commandBindings.map((item) => available.has(item.skill) ? item : { ...item, skill: manifests[0]?.name || item.skill }),
+        agents: {
+            codex: { ...config.agents.codex, commandFilePattern: "{id}.md", slashPattern: "/{id}" },
+            claudecode: {
+                ...config.agents.claudecode,
+                commandFilePattern: "{id}.md",
+                slashPattern: "/{id}"
+            },
+            iflow: { ...config.agents.iflow, commandFilePattern: "{id}.md", slashPattern: "/{id}" }
+        }
+    };
+}
+function buildSkillDrivenBindings(manifests) {
+    const used = new Set();
+    return manifests.map((manifest) => {
+        const base = commandIdForSkillName(manifest.name);
+        let id = base;
+        let i = 2;
+        while (used.has(id)) {
+            id = `${base}${i}`;
+            i += 1;
+        }
+        used.add(id);
+        return {
+            id,
+            skill: manifest.name,
+            description: `Run skill ${manifest.name}`
+        };
+    });
+}
+function commandIdForSkillName(skillName) {
+    const normalizedName = skillName
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, "-")
+        .replace(/^-+|-+$/g, "");
+    return `cd-${normalizedName || "skill"}`;
+}
+function failIfErrors(diagnostics) {
+    const warnings = diagnostics.filter((item) => item.level === "warning");
+    warnings.forEach((warning) => console.warn(`[warn] ${warning.message}`));
+    const errors = diagnostics.filter((item) => item.level === "error");
+    if (errors.length > 0) {
+        throw new Error(errors.map((error) => error.message).join("\n"));
+    }
+}

package/dist/skill-core/tool-interactions.js

@@ -0,0 +1,70 @@
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveAgentRoot } from "../config/path.js";
+import { ensureDir } from "../utils/fs.js";
+export async function installToolInteractionTemplates(cwd, target, skills, config) {
+    const agent = config.agents[target];
+    const root = resolveAgentRoot(cwd, agent.rootDir);
+    const commandsDir = path.join(root, agent.commandsDir);
+    await ensureDir(commandsDir);
+    const created = [];
+    for (const binding of config.commandBindings) {
+        const fileName = agent.commandFilePattern.replace("{id}", binding.id);
+        const file = path.join(commandsDir, fileName);
+        await writeFile(file, renderCommandTemplate(target, binding.id, binding.skill, binding.description), "utf8");
+        created.push(file);
+    }
+    const guidePath = agent.guideAtProjectRoot
+        ? path.join(cwd, agent.guideFile)
+        : path.join(root, agent.guideFile);
+    await writeFile(guidePath, renderGuide(target, skills, config), "utf8");
+    created.push(guidePath);
+    return created;
+}
+export async function writeSharedAgentsStub(cwd, targets, skills, config) {
+    const file = path.join(cwd, "AGENTS.md");
+    const lines = [
+        "# AGENTS instructions",
+        "",
+        "<INSTRUCTIONS>",
+        "## OpenSpec Setup",
+        `Enabled targets: ${targets.join(", ")}`,
+        "### Skills",
+        ...skills.map((skill) => `- ${skill.name}: ${skill.description || "No description"}`),
+        "### Command Bindings",
+        ...config.commandBindings.map((binding) => `- ${binding.id} -> ${binding.skill}`),
+        "</INSTRUCTIONS>",
+        ""
+    ];
+    await writeFile(file, lines.join("\n"), "utf8");
+    return file;
+}
+function renderCommandTemplate(target, commandId, skillName, description) {
+    return [
+        `# ${commandId} (${target})`,
+        "",
+        description,
+        "",
+        "## Skill binding",
+        `- skill: ${skillName}`,
+        "",
+        "## Required output",
+        "- Change ID",
+        "- Updated files",
+        "- Validation summary"
+    ].join("\n");
+}
+function renderGuide(target, skills, config) {
+    const agent = config.agents[target];
+    const commandList = config.commandBindings.map((binding) => `- ${agent.slashPattern.replace("{id}", binding.id)} -> ${binding.skill}`);
+    return [
+        `# ${target} OpenSpec-style setup`,
+        "",
+        "## Installed skills",
+        ...skills.map((skill) => `- ${skill.name}: ${skill.description || "No description"}`),
+        "",
+        "## Commands",
+        ...commandList,
+        ""
+    ].join("\n");
+}

package/dist/skill-core/types.js

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

package/dist/skill-core/validator.js

@@ -0,0 +1,25 @@
+export function validateManifest(manifest) {
+    const diagnostics = [];
+    if (!manifest.name) {
+        diagnostics.push({ level: "error", message: "Skill name is required." });
+    }
+    if (!manifest.description) {
+        diagnostics.push({
+            level: "error",
+            message: `Skill "${manifest.name}" is missing frontmatter description.`
+        });
+    }
+    if (!manifest.body) {
+        diagnostics.push({
+            level: "warning",
+            message: `Skill "${manifest.name}" has empty SKILL.md body.`
+        });
+    }
+    if (!/^[a-z0-9-]+$/.test(manifest.name)) {
+        diagnostics.push({
+            level: "warning",
+            message: `Skill "${manifest.name}" should use lowercase letters, numbers, and hyphens.`
+        });
+    }
+    return diagnostics;
+}

package/dist/task-core/parser.js

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

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

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

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