@tmddev/tmd 0.3.0 → 0.3.2

package/dist/commands/knowledge.js

@@ -0,0 +1,117 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join, resolve, dirname } from 'path';
+import chalk from 'chalk';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+const _dirname = dirname(fileURLToPath(import.meta.url));
+const TMD_KNOWLEDGE_BIN = join(_dirname, '..', process.platform === 'win32' ? 'tmd-knowledge.exe' : 'tmd-knowledge');
+function runTmdKnowledge(args) {
+    if (!existsSync(TMD_KNOWLEDGE_BIN)) {
+        console.error(chalk.red('✗ tmd-knowledge binary not found. Run pnpm build.'));
+        process.exit(1);
+    }
+    const r = spawnSync(TMD_KNOWLEDGE_BIN, args, {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'inherit'],
+    });
+    if (r.status !== 0) {
+        process.exit(r.status ?? 1);
+    }
+    return r.stdout;
+}
+function estimateTokens(content) {
+    // Rough estimation: Chinese ~1.5 tokens per character, English ~0.75 tokens per word
+    // For mixed content, use a conservative estimate: ~2 bytes per token for UTF-8
+    const bytes = Buffer.byteLength(content, 'utf8');
+    return Math.ceil(bytes / 2);
+}
+function readTextFiles(dir) {
+    const files = new Map();
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (entry.isFile()) {
+            const ext = entry.name.split('.').pop()?.toLowerCase();
+            if (ext === 'txt' || ext === 'md') {
+                const filePath = join(dir, entry.name);
+                try {
+                    const content = readFileSync(filePath, 'utf8');
+                    files.set(entry.name, content);
+                }
+                catch (error) {
+                    console.warn(chalk.yellow(`Warning: Could not read ${entry.name}: ${error}`));
+                }
+            }
+        }
+    }
+    return files;
+}
+export async function knowledgeCommand(action, options) {
+    if (action === 'create') {
+        const { knowledgeId, dir, agentId = 'summarizer' } = options;
+        if (!knowledgeId) {
+            console.error(chalk.red('✗ --knowledge-id is required'));
+            process.exit(1);
+        }
+        if (!dir) {
+            console.error(chalk.red('✗ --dir is required'));
+            process.exit(1);
+        }
+        const sourceDir = resolve(process.cwd(), dir);
+        if (!existsSync(sourceDir)) {
+            console.error(chalk.red(`✗ Directory does not exist: ${sourceDir}`));
+            process.exit(1);
+        }
+        console.log(chalk.blue(`\nCreating knowledge entry: ${knowledgeId}`));
+        console.log(chalk.gray(`Source directory: ${sourceDir}`));
+        console.log(chalk.gray(`Using agent: ${agentId}`));
+        // Read text files
+        const files = readTextFiles(sourceDir);
+        if (files.size === 0) {
+            console.warn(chalk.yellow('⚠ No .txt or .md files found in directory'));
+        }
+        console.log(chalk.blue(`\nFound ${files.size} file(s)`));
+        // Estimate tokens and check for large files
+        let totalTokens = 0;
+        const largeFiles = [];
+        for (const [name, content] of files.entries()) {
+            const tokens = estimateTokens(content);
+            totalTokens += tokens;
+            if (tokens > 100000) {
+                largeFiles.push({ name, tokens });
+            }
+            console.log(chalk.gray(`  ${name}: ~${tokens.toLocaleString()} tokens`));
+        }
+        if (largeFiles.length > 0) {
+            console.log(chalk.yellow(`\n⚠ Warning: ${largeFiles.length} file(s) exceed 100K tokens and will be chunked:`));
+            for (const file of largeFiles) {
+                console.log(chalk.yellow(`  ${file.name}: ~${file.tokens.toLocaleString()} tokens`));
+            }
+        }
+        console.log(chalk.blue('\nCreating knowledge entry with LLM summarization...'));
+        // Call Rust binary to create knowledge entry with LLM summarization
+        const cwd = process.cwd();
+        // Find knowledge.db - try .tmd/knowledge.db first, then fallback to project root
+        const knowledgeDbPath = join(cwd, '.tmd', 'knowledge.db');
+        const args = [
+            'create-from-dir',
+            '--project-root', cwd,
+            '--knowledge-id', knowledgeId,
+            '--source-dir', sourceDir,
+            '--agent-id', agentId,
+            '--knowledge-db', knowledgeDbPath,
+        ];
+        try {
+            runTmdKnowledge(args);
+            console.log(chalk.green(`✓ Knowledge entry created: ${knowledgeId}`));
+        }
+        catch (error) {
+            console.error(chalk.red(`✗ Failed to create knowledge entry: ${error}`));
+            process.exit(1);
+        }
+    }
+    else {
+        console.error(chalk.red(`Unknown action: ${action}`));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=knowledge.js.map

package/dist/commands/plan.d.ts

@@ -1,3 +1,3 @@
 import type { PlanCommandOptions } from '../types.js';
-export declare function planCommand(description: string, options: PlanCommandOptions): void;
+export declare function planCommand(description: string, options: PlanCommandOptions): Promise<void>;
 //# sourceMappingURL=plan.d.ts.map

package/dist/commands/plan.js

@@ -1,34 +1,155 @@
 import { ensureDir, getPlanDir } from '../utils/paths.js';
 import { generateTaskId } from '../utils/task-id.js';
 import { planTemplate, resourcesTemplate, renderTemplate } from '../utils/templates.js';
-import { updateTaskStatus } from '../utils/task-status.js';
-import { createOpenSpecChange } from '../utils/openspec.js';
+import { updateTaskMetadata, updateTaskStatus } from '../utils/task-status.js';
 import { createSkill } from '../utils/skills.js';
 import { extractTasks } from '../utils/tasks.js';
 import { validateTasks } from '../utils/task-validator.js';
+import { isOpenSpecProject, generateLLMPlan, showGenerationProgress } from '../utils/llm-plan.js';
+import { executionPlanFromGeneratedTasks, validateExecutionPlan } from '../utils/execution-plan.js';
 import { writeFileSync, existsSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
-export function planCommand(description, options) {
+function injectTasksIntoPlan(planContent, tasks) {
+    const marker = '## OpenSpec Change';
+    const i = planContent.indexOf(marker);
+    if (i < 0)
+        return planContent;
+    const before = planContent.slice(0, i);
+    const after = planContent.slice(i);
+    const tasksBlock = tasks.length
+        ? tasks.map((t, idx) => `- [ ] ${String(idx + 1)}. ${t.title}`).join('\n') + '\n'
+        : '- [ ] 1.\n- [ ] 2.\n- [ ] 3.\n';
+    // Replace everything after "## Tasks" heading up to the next section with a fresh list.
+    const tasksHeading = /##\s*Tasks[\s\S]*$/i;
+    if (!tasksHeading.test(before))
+        return planContent;
+    const replaced = before.replace(tasksHeading, (m) => {
+        // Keep the original Tasks heading and guidance comments (everything up to the first checklist item),
+        // then replace checklist with generated tasks.
+        const lines = m.split('\n');
+        const out = [];
+        let inChecklist = false;
+        for (const line of lines) {
+            if (/^\s*-\s+\[\s?[x ]?\s?]\s+/.test(line)) {
+                inChecklist = true;
+                continue;
+            }
+            if (!inChecklist)
+                out.push(line);
+        }
+        // Ensure there's exactly one blank line before the checklist.
+        if (out.length > 0 && out[out.length - 1]?.trim() !== '')
+            out.push('');
+        out.push(tasksBlock.trimEnd());
+        out.push('');
+        return out.join('\n');
+    });
+    return replaced + after;
+}
+export async function planCommand(description, options) {
     const taskId = generateTaskId(description);
     const planDir = getPlanDir(taskId);
-    ensureDir(planDir);
-    // Create plan.md
-    const planContent = renderTemplate(planTemplate, { description });
-    writeFileSync(join(planDir, 'plan.md'), planContent);
-    // Create resources.md
-    const resourcesContent = renderTemplate(resourcesTemplate, { description });
-    writeFileSync(join(planDir, 'resources.md'), resourcesContent);
-    // Initialize task status
-    updateTaskStatus(taskId, 'planning');
-    console.log(chalk.green(`✓ Created plan for task: ${taskId}`));
-    console.log(chalk.blue(`  Directory: ${planDir}`));
-    // OpenSpec integration
-    if (options.openspec) {
-        const changeId = createOpenSpecChange(description, taskId);
-        if (changeId) {
-            console.log(chalk.green(`  Linked to OpenSpec change: ${changeId}`));
+    // Check if spec features are enabled for this project
+    const isOpenSpec = isOpenSpecProject();
+    if (isOpenSpec) {
+        // LLM-powered proposal generation
+        const agentId = options.agentId || 'planner';
+        console.log(chalk.blue(`🤖 Using agent '${agentId}' to generate proposal...\n`));
+        const progress = showGenerationProgress();
+        progress.setStage('Analyzing requirements...');
+        const result = await generateLLMPlan({
+            description,
+            projectRoot: '.',
+            agentId,
+            onStage: (stage) => progress.setStage(stage),
+        });
+        progress.stop();
+        if (!result.success) {
+            console.log(chalk.red('\n✗ Failed to generate proposal:'));
+            console.log(chalk.red(`  ${result.error}`));
+            console.log(chalk.yellow('\n💡 Falling back to simple plan generation...\n'));
+            // Fall back to simple plan generation
+            ensureDir(planDir);
+            const planContent = renderTemplate(planTemplate, { description });
+            writeFileSync(join(planDir, 'plan.md'), planContent);
+            const resourcesContent = renderTemplate(resourcesTemplate, { description });
+            writeFileSync(join(planDir, 'resources.md'), resourcesContent);
+            updateTaskStatus(taskId, 'planning');
+            console.log(chalk.green(`✓ Created simple plan for task: ${taskId}`));
+            console.log(chalk.blue(`  Directory: ${planDir}`));
         }
+        else {
+            // Success! LLM generated the proposal
+            console.log(chalk.green('\n✓ Proposal generated successfully!'));
+            if (result.changeId) {
+                console.log(chalk.blue(`  Change ID: ${result.changeId}`));
+                console.log(chalk.blue(`  Location: .tmd/changes/${result.changeId}/`));
+            }
+            if (result.tasksCount) {
+                console.log(chalk.blue(`  Tasks: ${result.tasksCount}`));
+            }
+            if (result.specsCount) {
+                console.log(chalk.blue(`  Spec deltas: ${result.specsCount}`));
+            }
+            if (result.hasDesign) {
+                console.log(chalk.blue(`  Includes: design.md`));
+            }
+            // Also create the .tmd/plan directory for task tracking
+            ensureDir(planDir);
+            const planContentBase = renderTemplate(planTemplate, { description });
+            const planContent = result.tasks ? injectTasksIntoPlan(planContentBase, result.tasks) : planContentBase;
+            writeFileSync(join(planDir, 'plan.md'), planContent);
+            const resourcesContent = renderTemplate(resourcesTemplate, { description });
+            writeFileSync(join(planDir, 'resources.md'), resourcesContent);
+            // Create machine-readable execution plan artifact
+            if (result.tasks && result.tasks.length > 0) {
+                const execPlan = executionPlanFromGeneratedTasks({
+                    taskId,
+                    tasks: result.tasks,
+                    defaultAgentId: options.assignAgent || 'executor',
+                    generatedBy: 'tmd plan',
+                });
+                const issues = validateExecutionPlan(execPlan);
+                const hasError = issues.some((x) => x.level === 'error');
+                if (issues.length > 0) {
+                    console.log(chalk.blue('\nExecution Plan Validation:'));
+                    for (const it of issues) {
+                        const p = it.level === 'error' ? chalk.red('error') : chalk.yellow('warning');
+                        console.log(`  ${p}: ${it.message}`);
+                    }
+                }
+                if (hasError && options.strictDeps) {
+                    console.error(chalk.red('\n✗ Execution plan dependency validation failed (--strict-deps)'));
+                    process.exit(1);
+                }
+                writeFileSync(join(planDir, 'execution-plan.json'), JSON.stringify(execPlan, null, 2));
+            }
+            else {
+                console.log(chalk.yellow('\n⚠️  No generated tasks were returned; execution-plan.json was not created.'));
+            }
+            updateTaskStatus(taskId, 'planning');
+            if (result.changeId) {
+                updateTaskMetadata(taskId, { openspecChange: result.changeId });
+            }
+            console.log(chalk.green(`\n✓ Created task tracking: ${taskId}`));
+            console.log(chalk.blue(`  Directory: ${planDir}`));
+        }
+    }
+    else {
+        // Simple plan generation (spec features not enabled)
+        ensureDir(planDir);
+        // Create plan.md
+        const planContent = renderTemplate(planTemplate, { description });
+        writeFileSync(join(planDir, 'plan.md'), planContent);
+        // Create resources.md
+        const resourcesContent = renderTemplate(resourcesTemplate, { description });
+        writeFileSync(join(planDir, 'resources.md'), resourcesContent);
+        // Initialize task status
+        updateTaskStatus(taskId, 'planning');
+        console.log(chalk.green(`✓ Created plan for task: ${taskId}`));
+        console.log(chalk.blue(`  Directory: ${planDir}`));
+        console.log(chalk.dim('  (Spec features not enabled - using simple templates)'));
     }
     // Skill creation
     if (options.skill) {

package/dist/commands/server.d.ts

@@ -0,0 +1,7 @@
+export interface ServerCommandOptions {
+    host?: string;
+    port?: number;
+    projectRoot?: string;
+}
+export declare function serverCommand(options: ServerCommandOptions): void;
+//# sourceMappingURL=server.d.ts.map

package/dist/commands/server.js

@@ -0,0 +1,38 @@
+import { spawn } from 'child_process';
+import { existsSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const TMD_SERVER_BIN = join(__dirname, '..', process.platform === 'win32' ? 'tmd-server.exe' : 'tmd-server');
+export function serverCommand(options) {
+    if (!existsSync(TMD_SERVER_BIN)) {
+        console.error('✗ tmd-server binary not found. Run pnpm run build.');
+        process.exit(1);
+    }
+    const host = options.host ?? '127.0.0.1';
+    const port = options.port ?? 13300;
+    const projectRoot = options.projectRoot ?? process.cwd();
+    const args = ['--host', host, '--port', String(port), '--project-root', projectRoot];
+    const child = spawn(TMD_SERVER_BIN, args, { stdio: 'inherit' });
+    const forwardSignal = (sig) => {
+        // Forward to child (best-effort), then exit with same signal semantics.
+        try {
+            child.kill(sig);
+        }
+        catch {
+            // ignore
+        }
+    };
+    process.on('SIGINT', () => forwardSignal('SIGINT'));
+    process.on('SIGTERM', () => forwardSignal('SIGTERM'));
+    child.on('close', (code, signal) => {
+        // If child exits due to signal, reflect it.
+        if (signal) {
+            // Node doesn't allow setting exit signal directly; exit non-zero.
+            process.exit(1);
+        }
+        process.exit(code ?? 1);
+    });
+}
+//# sourceMappingURL=server.js.map

package/dist/commands/skills.js

@@ -22,6 +22,15 @@ function runTmdSkills(args) {
     }
     return r.stdout;
 }
+function runTmdSkillsInherit(args) {
+    if (!existsSync(TMD_SKILLS_BIN)) {
+        console.error(chalk.red('✗ tmd-skills binary not found. Run pnpm build.'));
+        process.exit(1);
+    }
+    const r = spawnSync(TMD_SKILLS_BIN, args, { stdio: 'inherit' });
+    if (r.status !== 0)
+        process.exit(r.status ?? 1);
+}
 function runTmdSkillsRemove(skillName, all) {
     if (!existsSync(TMD_SKILLS_BIN)) {
         console.error(chalk.red('✗ tmd-skills binary not found. Run pnpm build.'));
@@ -50,21 +59,38 @@ export async function skillsCommand(action, name, options) {
     const cwd = process.cwd();
     const base = () => ['--project-root', cwd];
     if (!action || action === 'list') {
+        // Default: show npx canonical store (project `./skills/` or `~/skills/` with --global).
+        const outNpx = runTmdSkills([
+            'list-npx',
+            ...base(),
+            ...(options?.global ? ['--global'] : []),
+            ...tagArgs(options?.tag),
+        ]);
+        const canonical = JSON.parse(outNpx || '[]');
+        if (canonical.length > 0) {
+            console.log(chalk.bold('\nInstalled Skills (canonical store):'));
+            console.log('─'.repeat(60));
+            for (const s of canonical) {
+                console.log(`  ${chalk.cyan(s.name)}`);
+                if (s.description)
+                    console.log(`    ${chalk.gray(s.description)}`);
+            }
+            console.log('─'.repeat(60));
+            console.log(chalk.gray(`Total: ${String(canonical.length)} skill(s)`));
+            return;
+        }
+        // Fallback: show TMD-managed skills (useful for skills created via tmd).
         const out = runTmdSkills(['list', ...base(), ...tagArgs(options?.tag)]);
         const skills = JSON.parse(out || '[]');
         if (skills.length === 0) {
-            console.log(chalk.yellow('No skills found. Create one with: tmd plan "description" --skill'));
-            console.log(chalk.gray('Or add from skills.sh: tmd skills add <owner/repo>'));
+            console.log(chalk.yellow('No skills found.'));
+            console.log(chalk.gray('Install with: tmd skills add <owner/repo>'));
             return;
         }
-        console.log(chalk.bold('\nAvailable Skills:'));
+        console.log(chalk.bold('\nAvailable Skills (tmd-managed):'));
         console.log('─'.repeat(60));
         for (const s of skills) {
-            let sourceTag = '';
-            if (s.source === 'skillssh')
-                sourceTag = chalk.magenta(' [skills.sh]');
-            else if (s.source === 'github')
-                sourceTag = chalk.blue(' [github]');
+            const sourceTag = s.source === 'github' ? chalk.blue(' [github]') : '';
             const repoInfo = s.repo ? chalk.gray(` (${s.repo})`) : '';
             console.log(`  ${chalk.cyan(s.name)}${sourceTag}${repoInfo}`);
             console.log(`    ${chalk.gray(s.description || 'No description')}`);
@@ -101,13 +127,7 @@ export async function skillsCommand(action, name, options) {
         }
         console.log(chalk.bold('\nMetadata:'));
         console.log(`  Version: ${skill.version ?? 'N/A'}`);
-        if (skill.source === 'skillssh') {
-            console.log(`  Source: ${chalk.magenta('skills.sh')}`);
-            console.log(`  Repository: ${skill.repo ?? 'N/A'}`);
-            if (skill.imported_at)
-                console.log(`  Imported: ${skill.imported_at}`);
-        }
-        else if (skill.source === 'github') {
+        if (skill.source === 'github') {
             console.log(`  Source: ${chalk.blue('GitHub')}`);
             console.log(`  Repository: ${skill.repo ?? 'N/A'}`);
             if (skill.branch)
@@ -154,6 +174,38 @@ export async function skillsCommand(action, name, options) {
         }
         void invokeSkill(name, options?.input, skillsDir);
     }
+    else if (action === 'find') {
+        runTmdSkillsInherit(['npx-find', ...(name ? [name] : [])]);
+        return;
+    }
+    else if (action === 'check') {
+        runTmdSkillsInherit(['npx-check']);
+        return;
+    }
+    else if (action === 'generate-lock') {
+        runTmdSkillsInherit(['npx-generate-lock']);
+        return;
+    }
+    else if (action === 'init') {
+        runTmdSkillsInherit(['npx-init', ...(name ? [name] : [])]);
+        return;
+    }
+    else if (action === 'sync') {
+        // Sync npx canonical store into .agents/.tmd and upsert to .tmd/skills.db.
+        // - default source store: ./skills
+        // - with -g/--global: ~/skills
+        const out = runTmdSkills([
+            'sync-npx',
+            ...base(),
+            ...(name ? ['--source', name] : []),
+            ...(options?.global ? ['--global'] : []),
+            ...(options?.all ? ['--all'] : []),
+            ...(options?.force ? ['--force'] : []),
+        ]);
+        const skills = JSON.parse(out || '[]');
+        console.log(chalk.green(`✓ Synced ${String(skills.length)} skill(s) from npx canonical store`));
+        return;
+    }
     else if (action === 'add') {
         if (!name) {
             console.error(chalk.red('✗ Repository required (format: owner/repo)'));
@@ -161,26 +213,48 @@ export async function skillsCommand(action, name, options) {
         }
         if (options?.github) {
             console.log(chalk.blue(`\nAdding skill from GitHub: ${name}`));
-            if (options.skill)
+            if (options?.skill)
                 console.log(chalk.gray(`  Skill: ${options.skill}`));
-            if (options.branch)
+            if (options?.branch)
                 console.log(chalk.gray(`  Branch: ${options.branch}`));
             console.log('─'.repeat(60));
-            const args = ['import-github', name, ...base(), ...(options.skill ? ['--skill', options.skill] : []), ...(options.branch ? ['--branch', options.branch] : []), ...(options.force ? ['--force'] : []), ...(options.all ? ['--all'] : [])];
-            const out = runTmdSkills(args);
+            const ghArgs = [
+                'import-github',
+                name,
+                ...base(),
+                ...(options?.skill ? ['--skill', options.skill] : []),
+                ...(options?.branch ? ['--branch', options.branch] : []),
+                ...(options?.force ? ['--force'] : []),
+                ...(options?.all ? ['--all'] : []),
+            ];
+            const out = runTmdSkills(ghArgs);
             const skill = JSON.parse(out);
             console.log(chalk.green(`✓ Skill added: ${skill.name}`));
             console.log(chalk.gray(`  Location: ${getSkillDir(skill.name)}`));
+            return;
         }
-        else {
-            console.log(chalk.blue(`\nAdding skill from skills.sh: ${name}${options?.skill != null ? ` (skill: ${options.skill})` : ''}`));
-            console.log('─'.repeat(60));
-            const args = ['import-skillssh', name, ...base(), ...(options?.skill ? ['--skill', options.skill] : []), ...(options?.all ? ['--all'] : [])];
-            const out = runTmdSkills(args);
-            const skill = JSON.parse(out);
-            console.log(chalk.green(`✓ Skill added: ${skill.name}`));
-            console.log(chalk.gray(`  Location: ${getSkillDir(skill.name)}`));
+        // Default: use Rust `tmd-skills npx-add` (it invokes npx, syncs to .tmd/.agents, and upserts to .tmd/skills.db;
+        // if npx fails, it falls back to GitHub import inside the Rust binary).
+        const args = [
+            'npx-add',
+            name,
+            ...base(),
+            ...(options?.global ? ['--global'] : []),
+            ...(options?.yes ? ['--yes'] : []),
+            ...(options?.list ? ['--list'] : []),
+            ...(options?.all ? ['--all'] : []),
+            ...(options?.force ? ['--force'] : []),
+            ...(options?.branch ? ['--branch', options.branch] : []),
+            ...(options?.agent ? options.agent.flatMap((a) => ['--agent', a]) : []),
+            ...(options?.skill ? ['--skill', options.skill] : []),
+        ];
+        if (options?.list) {
+            runTmdSkillsInherit(args);
+            return;
         }
+        const out = runTmdSkills(args);
+        const synced = JSON.parse(out || '[]');
+        console.log(chalk.green(`✓ Skill(s) installed and synced: ${String(synced.length)}`));
     }
     else if (action === 'create') {
         if (!name) {
@@ -193,9 +267,21 @@ export async function skillsCommand(action, name, options) {
         console.log(chalk.gray(`  Location: ${getSkillDir(name)}`));
     }
     else if (action === 'update') {
+        // Two modes:
+        // - `tmd skills update` (no name): delegate to `npx skills update` and re-sync DB.
+        // - `tmd skills update <name> --description/--tags`: update TMD metadata via Rust.
         if (!name) {
-            console.error(chalk.red('✗ Skill name required for update'));
-            process.exit(1);
+            const out = runTmdSkills([
+                'npx-update',
+                ...base(),
+                ...(options?.global ? ['--global'] : []),
+                ...(options?.yes ? ['--yes'] : []),
+                ...(options?.all ? ['--all'] : []),
+                ...(options?.agent ? options.agent.flatMap((a) => ['--agent', a]) : []),
+            ]);
+            const synced = JSON.parse(out || '[]');
+            console.log(chalk.green(`✓ Updated and synced ${String(synced.length)} skill(s)`));
+            return;
         }
         const o = options ?? {};
         const hasDesc = o.description != null;
@@ -231,7 +317,7 @@ export async function skillsCommand(action, name, options) {
     }
     else {
         console.error(chalk.red(`✗ Unknown action: ${action}`));
-        console.log(chalk.gray('Available actions: list, search, show, invoke, add, create, update, remove'));
+        console.log(chalk.gray('Available actions: list, search, show, invoke, add, find, check, update, init, generate-lock, sync, create, remove'));
         process.exit(1);
     }
 }

package/dist/commands/spec.d.ts

@@ -0,0 +1,19 @@
+export interface SpecValidateOptions {
+    all?: boolean;
+    specs?: boolean;
+    changes?: boolean;
+    strict?: boolean;
+    json?: boolean;
+    noInteractive?: boolean;
+}
+export declare function specListCommand(opts?: {
+    json?: boolean;
+}): void;
+export declare function specShowCommand(specId: string, opts?: {
+    json?: boolean;
+}): void;
+export declare function specValidateCommand(item: string | undefined, opts?: SpecValidateOptions): void;
+export declare function specArchiveCommand(changeId: string, opts?: {
+    yes?: boolean;
+}): void;
+//# sourceMappingURL=spec.d.ts.map

package/dist/commands/spec.js

@@ -0,0 +1,73 @@
+import { existsSync } from 'fs';
+import { spawnSync } from 'child_process';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import chalk from 'chalk';
+const _dirname = dirname(fileURLToPath(import.meta.url));
+const TMD_SPEC_BIN = join(_dirname, '..', process.platform === 'win32' ? 'tmd-spec.exe' : 'tmd-spec');
+function runTmdSpec(args) {
+    if (!existsSync(TMD_SPEC_BIN)) {
+        console.error(chalk.red('✗ tmd-spec binary not found. Run pnpm build.'));
+        process.exit(1);
+    }
+    const r = spawnSync(TMD_SPEC_BIN, args, { encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit'] });
+    if (r.status !== 0)
+        process.exit(r.status ?? 1);
+    return r.stdout;
+}
+export function specListCommand(opts = {}) {
+    const cwd = process.cwd();
+    const out = runTmdSpec(['list', '--project-root', cwd, ...(opts.json ? ['--json'] : [])]);
+    if (opts.json) {
+        console.log(out.trim() === '' ? '[]' : out);
+        return;
+    }
+    const specs = JSON.parse(out || '[]');
+    if (specs.length === 0) {
+        console.log(chalk.yellow('No specs found. Create `.tmd/specs/<capability>/spec.md` to enable spec mode.'));
+        return;
+    }
+    console.log(chalk.bold('\nSpecs:'));
+    for (const s of specs)
+        console.log(`  ${chalk.cyan(s.id)} ${chalk.gray(`requirements ${String(s.requirements)}`)}`);
+}
+export function specShowCommand(specId, opts = {}) {
+    if (!specId) {
+        console.error(chalk.red('✗ spec-id required'));
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const out = runTmdSpec(['show', specId, '--project-root', cwd, ...(opts.json ? ['--json'] : [])]);
+    console.log(out);
+}
+export function specValidateCommand(item, opts = {}) {
+    const cwd = process.cwd();
+    const args = ['validate', ...(item ? [item] : []), '--project-root', cwd];
+    if (opts.all)
+        args.push('--all');
+    if (opts.specs)
+        args.push('--specs');
+    if (opts.changes)
+        args.push('--changes');
+    if (opts.strict)
+        args.push('--strict');
+    if (opts.noInteractive)
+        args.push('--no-interactive');
+    if (opts.json)
+        args.push('--json');
+    const out = runTmdSpec(args);
+    console.log(out);
+}
+export function specArchiveCommand(changeId, opts = {}) {
+    if (!changeId) {
+        console.error(chalk.red('✗ change-id required'));
+        process.exit(1);
+    }
+    const cwd = process.cwd();
+    const args = ['archive', changeId, '--project-root', cwd];
+    if (opts.yes)
+        args.push('--yes');
+    runTmdSpec(args);
+    console.log(chalk.green(`✓ Archived change: ${changeId}`));
+}
+//# sourceMappingURL=spec.js.map

package/dist/commands/ui.d.ts

@@ -0,0 +1,2 @@
+export declare function uiCommand(): void;
+//# sourceMappingURL=ui.d.ts.map