@tmddev/tmd 0.1.0

package/dist/commands/do.js

@@ -0,0 +1,310 @@
+import { existsSync, appendFileSync, readFileSync } from 'fs';
+import { ensureDir, getDoDir, getPlanDir } from '../utils/paths.js';
+import { executionTemplate, renderTemplate } from '../utils/templates.js';
+import { updateTaskStatus as updatePhaseStatus } from '../utils/task-status.js';
+import { executeSkill } from '../utils/skills.js';
+import { extractTasks, updateTaskStatus, detectSkillReference } from '../utils/tasks.js';
+import { executeConcurrently } from '../utils/task-chain.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+function displayTasks(tasks, showProgress = true) {
+    if (tasks.length === 0) {
+        console.log(chalk.yellow('  No tasks found in plan.md'));
+        return;
+    }
+    const completed = tasks.filter(t => t.completed).length;
+    const total = tasks.length;
+    const percentage = total > 0 ? Math.round((completed / total) * 100) : 0;
+    if (showProgress) {
+        console.log(chalk.blue(`\n  Task Progress: ${String(completed)}/${String(total)} (${String(percentage)}%)`));
+    }
+    console.log(chalk.blue('\n  Tasks:'));
+    for (const task of tasks) {
+        const checkbox = task.completed ? chalk.green('[x]') : chalk.gray('[ ]');
+        const index = chalk.dim(`[${String(task.index)}]`);
+        console.log(`    ${checkbox} ${index} ${task.content}`);
+        // Show dependencies if present
+        if (task.dependencies && task.dependencies.length > 0) {
+            const deps = task.dependencies.map(d => `task-${String(d)}`).join(', ');
+            console.log(chalk.gray(`      → depends: ${deps}`));
+        }
+        // Show skill reference if present
+        const skillRef = detectSkillReference(task.content);
+        if (skillRef) {
+            console.log(chalk.gray(`      → skill: ${skillRef}`));
+        }
+    }
+}
+function recordTaskCompletion(doDir, taskIndex, taskContent) {
+    const executionPath = join(doDir, 'execution.md');
+    const timestamp = new Date().toISOString();
+    let executionContent = '';
+    if (existsSync(executionPath)) {
+        executionContent = readFileSync(executionPath, 'utf-8');
+    }
+    else {
+        executionContent = renderTemplate(executionTemplate, { taskId: '' });
+    }
+    // Append task completion record
+    const completionRecord = `\n## Task Completions\n\n- [${timestamp}] Task ${String(taskIndex)}: ${taskContent}\n`;
+    // Check if "Task Completions" section exists
+    if (executionContent.includes('## Task Completions')) {
+        // Append to existing section
+        executionContent = executionContent.replace(/(## Task Completions\n\n)/, `$1- [${timestamp}] Task ${String(taskIndex)}: ${taskContent}\n`);
+    }
+    else {
+        // Add new section before "## Issues Encountered" or at the end
+        if (executionContent.includes('## Issues Encountered')) {
+            executionContent = executionContent.replace(/(## Issues Encountered)/, `## Task Completions\n\n- [${timestamp}] Task ${String(taskIndex)}: ${taskContent}\n\n$1`);
+        }
+        else {
+            executionContent += completionRecord;
+        }
+    }
+    writeFileSync(executionPath, executionContent, 'utf-8');
+}
+function recordConcurrentExecution(doDir, results) {
+    const executionPath = join(doDir, 'execution.md');
+    const timestamp = new Date().toISOString();
+    let executionContent = '';
+    if (existsSync(executionPath)) {
+        executionContent = readFileSync(executionPath, 'utf-8');
+    }
+    else {
+        executionContent = renderTemplate(executionTemplate, { taskId: '' });
+    }
+    const successCount = results.filter(r => r.success).length;
+    const failCount = results.length - successCount;
+    const summary = `\n## Concurrent Execution Results\n\n- Execution started: ${timestamp}\n- Total tasks: ${String(results.length)}\n- Successful: ${String(successCount)}\n- Failed: ${String(failCount)}\n\n### Task Results\n\n`;
+    let resultsList = '';
+    for (const result of results) {
+        const status = result.success ? 'SUCCESS' : 'FAILED';
+        const errorInfo = result.error ? ` (${result.error})` : '';
+        resultsList += `- Task ${String(result.taskIndex)}: ${status} (${String(result.duration)}ms)${errorInfo}\n`;
+    }
+    const resultsSection = summary + resultsList;
+    // Check if "Concurrent Execution Results" section exists
+    if (executionContent.includes('## Concurrent Execution Results')) {
+        // Replace existing section
+        executionContent = executionContent.replace(/## Concurrent Execution Results[\s\S]*?(?=\n## |$)/, resultsSection.trim());
+    }
+    else {
+        // Add new section before "## Issues Encountered" or at the end
+        if (executionContent.includes('## Issues Encountered')) {
+            executionContent = executionContent.replace(/(## Issues Encountered)/, `${resultsSection}\n$1`);
+        }
+        else {
+            executionContent += resultsSection;
+        }
+    }
+    writeFileSync(executionPath, executionContent, 'utf-8');
+}
+function recordSkillExecution(doDir, skillName, success, error) {
+    const executionPath = join(doDir, 'execution.md');
+    const timestamp = new Date().toISOString();
+    let executionContent = '';
+    if (existsSync(executionPath)) {
+        executionContent = readFileSync(executionPath, 'utf-8');
+    }
+    else {
+        executionContent = renderTemplate(executionTemplate, { taskId: '' });
+    }
+    const status = success ? 'SUCCESS' : 'FAILED';
+    const skillRecord = `- [${timestamp}] Skill: ${skillName} - ${status}${error ? ` (${error})` : ''}\n`;
+    // Check if "Skill Executions" section exists
+    if (executionContent.includes('## Skill Executions')) {
+        // Append to existing section
+        executionContent = executionContent.replace(/(## Skill Executions\n\n)/, `$1${skillRecord}`);
+    }
+    else {
+        // Add new section before "## Issues Encountered" or at the end
+        const skillSection = `\n## Skill Executions\n\n${skillRecord}`;
+        if (executionContent.includes('## Issues Encountered')) {
+            executionContent = executionContent.replace(/(## Issues Encountered)/, `${skillSection}\n$1`);
+        }
+        else {
+            executionContent += skillSection;
+        }
+    }
+    writeFileSync(executionPath, executionContent, 'utf-8');
+}
+export async function doCommand(taskId, options) {
+    // Validate plan exists
+    const planPath = join(getPlanDir(taskId), 'plan.md');
+    if (!existsSync(planPath)) {
+        console.error(chalk.red(`✗ Plan not found for task: ${taskId}`));
+        process.exit(1);
+    }
+    // Extract tasks from plan
+    const tasks = extractTasks(planPath);
+    // Handle --list option: show task status without modifying
+    if (options.list) {
+        console.log(chalk.blue(`\nTask Status for: ${taskId}`));
+        displayTasks(tasks, true);
+        return;
+    }
+    // Handle --task option: mark specific task as complete
+    if (options.task !== undefined) {
+        const taskIndex = options.task;
+        const task = tasks.find(t => t.index === taskIndex);
+        if (!task) {
+            console.error(chalk.red(`✗ Task at index ${String(taskIndex)} not found`));
+            process.exit(1);
+        }
+        if (task.completed) {
+            console.log(chalk.yellow(`  Task ${String(taskIndex)} is already completed`));
+            return;
+        }
+        const doDir = getDoDir(taskId);
+        ensureDir(doDir);
+        // Ensure execution.md exists
+        const executionPath = join(doDir, 'execution.md');
+        if (!existsSync(executionPath)) {
+            const executionContent = renderTemplate(executionTemplate, { taskId });
+            writeFileSync(executionPath, executionContent);
+        }
+        // If --skill option is provided, execute skill first and only mark complete if successful
+        // Otherwise, mark task as complete immediately
+        const hasSkillOption = !!options.skill;
+        const skillRef = detectSkillReference(task.content);
+        const shouldExecuteSkill = hasSkillOption || skillRef;
+        if (shouldExecuteSkill) {
+            try {
+                // Execute skill from --skill option if provided
+                if (options.skill) {
+                    await executeSkill(options.skill, taskId, false); // Sequential for single task execution
+                    recordSkillExecution(doDir, options.skill, true);
+                }
+                // Check for skill reference and execute if present
+                if (skillRef) {
+                    console.log(chalk.blue(`  Detected skill reference: ${skillRef}`));
+                    await executeSkill(skillRef, taskId, false); // Sequential for single task execution
+                    recordSkillExecution(doDir, skillRef, true);
+                }
+                // Only mark task as complete if skill execution succeeded
+                updateTaskStatus(planPath, taskIndex, true);
+                recordTaskCompletion(doDir, taskIndex, task.content);
+                console.log(chalk.green(`✓ Task ${String(taskIndex)} marked as complete`));
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                // Record failed skill execution
+                if (options.skill) {
+                    recordSkillExecution(doDir, options.skill, false, errorMessage);
+                }
+                if (skillRef) {
+                    recordSkillExecution(doDir, skillRef, false, errorMessage);
+                }
+                console.error(chalk.red(`✗ Skill execution failed. Task ${String(taskIndex)} not marked as complete.`));
+                throw error;
+            }
+        }
+        else {
+            // No skill execution required, mark task as complete immediately
+            updateTaskStatus(planPath, taskIndex, true);
+            recordTaskCompletion(doDir, taskIndex, task.content);
+            console.log(chalk.green(`✓ Task ${String(taskIndex)} marked as complete`));
+        }
+        // Show updated task list
+        const updatedTasks = extractTasks(planPath);
+        displayTasks(updatedTasks, true);
+        return;
+    }
+    // Normal execution: start do phase
+    const doDir = getDoDir(taskId);
+    ensureDir(doDir);
+    // Create execution.md if it doesn't exist
+    const executionPath = join(doDir, 'execution.md');
+    if (!existsSync(executionPath)) {
+        const executionContent = renderTemplate(executionTemplate, { taskId });
+        writeFileSync(executionPath, executionContent);
+    }
+    // Create data.md if it doesn't exist
+    const dataPath = join(doDir, 'data.md');
+    if (!existsSync(dataPath)) {
+        writeFileSync(dataPath, '# Data Collection\n\n');
+    }
+    // Update task status
+    updatePhaseStatus(taskId, 'doing');
+    console.log(chalk.green(`✓ Started execution phase for task: ${taskId}`));
+    console.log(chalk.blue(`  Directory: ${doDir}`));
+    // Display tasks with progress
+    displayTasks(tasks, true);
+    // Concurrent execution if enabled
+    if (options.parallel) {
+        const maxConcurrency = options.maxConcurrency ?? Infinity;
+        const incompleteTasks = tasks.filter(t => !t.completed);
+        if (incompleteTasks.length === 0) {
+            console.log(chalk.yellow('  All tasks already completed'));
+        }
+        else {
+            console.log(chalk.blue(`\n  Executing ${String(incompleteTasks.length)} tasks concurrently (max: ${maxConcurrency === Infinity ? 'unlimited' : String(maxConcurrency)})...`));
+            try {
+                const results = await executeConcurrently(incompleteTasks, async (task) => {
+                    const startTime = Date.now();
+                    try {
+                        // Execute task (mark as complete)
+                        updateTaskStatus(planPath, task.index, true);
+                        recordTaskCompletion(doDir, task.index, task.content);
+                        // Execute skill if referenced (with parallel support)
+                        const skillRef = detectSkillReference(task.content);
+                        if (skillRef) {
+                            await executeSkill(skillRef, taskId, options.parallel, options.maxConcurrency);
+                            recordSkillExecution(doDir, skillRef, true);
+                        }
+                        const duration = Date.now() - startTime;
+                        console.log(chalk.green(`  ✓ Task ${String(task.index)} completed (${String(duration)}ms)`));
+                        return {
+                            taskIndex: task.index,
+                            success: true,
+                            duration
+                        };
+                    }
+                    catch (error) {
+                        const duration = Date.now() - startTime;
+                        const errorMessage = error instanceof Error ? error.message : String(error);
+                        console.error(chalk.red(`  ✗ Task ${String(task.index)} failed: ${errorMessage}`));
+                        return {
+                            taskIndex: task.index,
+                            success: false,
+                            error: errorMessage,
+                            duration
+                        };
+                    }
+                }, maxConcurrency);
+                // Record concurrent execution results
+                recordConcurrentExecution(doDir, results);
+                // Display summary
+                const successCount = results.filter(r => r.success).length;
+                const failCount = results.length - successCount;
+                console.log(chalk.blue(`\n  Execution Summary:`));
+                console.log(chalk.green(`    Successful: ${String(successCount)}`));
+                if (failCount > 0) {
+                    console.log(chalk.red(`    Failed: ${String(failCount)}`));
+                }
+                // Show updated task list
+                const updatedTasks = extractTasks(planPath);
+                displayTasks(updatedTasks, true);
+            }
+            catch (error) {
+                const errorMessage = error instanceof Error ? error.message : String(error);
+                console.error(chalk.red(`✗ Concurrent execution failed: ${errorMessage}`));
+                throw error;
+            }
+        }
+    }
+    // Data collection
+    if (options.data) {
+        const [key, value] = options.data.split('=');
+        const safeKey = key ?? '';
+        const safeValue = value ?? '';
+        appendFileSync(dataPath, `- ${safeKey}: ${safeValue}\n`);
+        console.log(chalk.green(`  Recorded data: ${safeKey}=${safeValue}`));
+    }
+    // Skill execution
+    if (options.skill) {
+        await executeSkill(options.skill, taskId, options.parallel, options.maxConcurrency);
+    }
+}
+//# sourceMappingURL=do.js.map

package/dist/commands/list.d.ts

@@ -0,0 +1,3 @@
+import type { ListCommandOptions } from '../types.js';
+export declare function listCommand(options: ListCommandOptions): void;
+//# sourceMappingURL=list.d.ts.map

package/dist/commands/list.js

@@ -0,0 +1,56 @@
+import { readdirSync, existsSync } from 'fs';
+import { getTmdDir } from '../utils/paths.js';
+import { getTaskStatus } from '../utils/task-status.js';
+import { join } from 'path';
+import chalk from 'chalk';
+export function listCommand(options) {
+    const tmdDir = getTmdDir();
+    if (!existsSync(tmdDir)) {
+        console.log(chalk.yellow('No tasks found. Create one with: tmd plan "description"'));
+        return;
+    }
+    const planDir = join(tmdDir, 'plan');
+    if (!existsSync(planDir)) {
+        console.log(chalk.yellow('No tasks found. Create one with: tmd plan "description"'));
+        return;
+    }
+    let tasks = readdirSync(planDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    if (tasks.length === 0) {
+        console.log(chalk.yellow('No tasks found. Create one with: tmd plan "description"'));
+        return;
+    }
+    // Filter by status if provided
+    if (options.status) {
+        tasks = tasks.filter(taskId => getTaskStatus(taskId) === options.status);
+    }
+    // Filter by phase if provided
+    if (options.phase) {
+        tasks = tasks.filter(taskId => {
+            const status = getTaskStatus(taskId);
+            return status === options.phase ||
+                (options.phase === 'plan' && status === 'planning') ||
+                (options.phase === 'do' && status === 'doing') ||
+                (options.phase === 'check' && status === 'checking') ||
+                (options.phase === 'act' && status === 'acting');
+        });
+    }
+    if (tasks.length === 0) {
+        console.log(chalk.yellow('No tasks found matching the criteria'));
+        return;
+    }
+    console.log(chalk.bold('\nTasks:'));
+    console.log('─'.repeat(60));
+    for (const taskId of tasks) {
+        const status = getTaskStatus(taskId);
+        const statusColor = status === 'completed' ? chalk.green :
+            status === 'acting' ? chalk.blue :
+                status === 'checking' ? chalk.yellow :
+                    status === 'doing' ? chalk.cyan : chalk.gray;
+        console.log(`  ${chalk.cyan(taskId)} - ${statusColor(status)}`);
+    }
+    console.log('─'.repeat(60));
+    console.log(chalk.gray(`Total: ${String(tasks.length)} task(s)`));
+}
+//# sourceMappingURL=list.js.map

package/dist/commands/plan.d.ts

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

package/dist/commands/plan.js

@@ -0,0 +1,89 @@
+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 { createSkill } from '../utils/skills.js';
+import { extractTasks } from '../utils/tasks.js';
+import { validateTasks } from '../utils/task-validator.js';
+import { writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+export 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}`));
+        }
+    }
+    // Skill creation
+    if (options.skill) {
+        const skillName = createSkill(description, taskId);
+        if (skillName) {
+            console.log(chalk.green(`  Created skill: ${skillName}`));
+        }
+    }
+    // Use existing skill
+    if (options.useSkill) {
+        console.log(chalk.blue(`  Using skill: ${options.useSkill}`));
+        // TODO: Link skill to task
+    }
+    // Task validation
+    if (options.validateTasks) {
+        const planPath = join(planDir, 'plan.md');
+        if (existsSync(planPath)) {
+            const tasks = extractTasks(planPath);
+            if (tasks.length > 0) {
+                const taskDescriptions = tasks.map(t => t.content);
+                const validation = validateTasks(taskDescriptions);
+                console.log(chalk.blue('\n📋 Task Size Validation:'));
+                console.log(chalk.blue(`  Total tasks: ${String(validation.summary.total)}`));
+                console.log(chalk.green(`  Valid (pee-break sized): ${String(validation.summary.valid)}`));
+                if (validation.summary.invalid > 0) {
+                    console.log(chalk.yellow(`  ⚠️  Tasks that may exceed 10 minutes: ${String(validation.summary.invalid)}`));
+                    console.log(chalk.yellow(`  Large tasks: ${String(validation.summary.large)}\n`));
+                    validation.results.forEach((result, index) => {
+                        if (!result.isValid) {
+                            const task = tasks[index];
+                            if (task) {
+                                console.log(chalk.yellow(`  Task ${String(task.index + 1)}: "${task.content}"`));
+                                console.log(chalk.yellow(`    Estimated: ${String(result.estimate.estimatedMinutes)} minutes (${result.estimate.category})`));
+                                if (result.warning) {
+                                    console.log(chalk.yellow(`    ⚠️  ${result.warning}`));
+                                }
+                                if (result.suggestions && result.suggestions.length > 0) {
+                                    console.log(chalk.blue(`    💡 Suggestions:`));
+                                    result.suggestions.slice(0, 3).forEach(suggestion => {
+                                        console.log(chalk.blue(`      - ${suggestion}`));
+                                    });
+                                }
+                                console.log('');
+                            }
+                        }
+                    });
+                }
+                else {
+                    console.log(chalk.green('  ✓ All tasks are pee-break sized (10 seconds to 10 minutes)\n'));
+                }
+            }
+            else {
+                console.log(chalk.blue('  No tasks found in plan.md yet'));
+            }
+        }
+    }
+}
+//# sourceMappingURL=plan.js.map

package/dist/commands/show.d.ts

@@ -0,0 +1,2 @@
+export declare function showCommand(taskId: string): Promise<void>;
+//# sourceMappingURL=show.d.ts.map

package/dist/commands/show.js

@@ -0,0 +1,69 @@
+import { existsSync, readFileSync } from 'fs';
+import { getPlanDir, getDoDir, getCheckDir, getActDir } from '../utils/paths.js';
+import { join } from 'path';
+import chalk from 'chalk';
+export async function showCommand(taskId) {
+    const planDir = getPlanDir(taskId);
+    const planPath = join(planDir, 'plan.md');
+    if (!existsSync(planPath)) {
+        console.error(chalk.red(`✗ Task not found: ${taskId}`));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`\nTask: ${chalk.cyan(taskId)}`));
+    console.log('─'.repeat(60));
+    // Read plan
+    if (existsSync(planPath)) {
+        const planContent = readFileSync(planPath, 'utf-8');
+        const firstLine = planContent.split('\n')[0] ?? '';
+        console.log(chalk.bold('\nPlan:'));
+        console.log(`  ${firstLine.replace('# Plan: ', '')}`);
+    }
+    // Check phase status
+    const phases = [];
+    if (existsSync(join(getPlanDir(taskId), 'plan.md'))) {
+        phases.push('Plan');
+    }
+    if (existsSync(join(getDoDir(taskId), 'execution.md'))) {
+        phases.push('Do');
+    }
+    if (existsSync(join(getCheckDir(taskId), 'evaluation.md'))) {
+        phases.push('Check');
+    }
+    if (existsSync(join(getActDir(taskId), 'improvement.md'))) {
+        phases.push('Act');
+    }
+    console.log(chalk.bold('\nCurrent Phase:'));
+    console.log(`  ${phases[phases.length - 1] ?? 'Plan'}`);
+    console.log(chalk.bold('\nCompleted Phases:'));
+    phases.forEach(phase => {
+        console.log(`  ${chalk.green('✓')} ${phase}`);
+    });
+    console.log(chalk.bold('\nDirectories:'));
+    console.log(`  Plan: ${chalk.blue(getPlanDir(taskId))}`);
+    if (existsSync(getDoDir(taskId))) {
+        console.log(`  Do: ${chalk.blue(getDoDir(taskId))}`);
+    }
+    if (existsSync(getCheckDir(taskId))) {
+        console.log(`  Check: ${chalk.blue(getCheckDir(taskId))}`);
+    }
+    if (existsSync(getActDir(taskId))) {
+        console.log(`  Act: ${chalk.blue(getActDir(taskId))}`);
+    }
+    // OpenSpec link
+    const { getTaskMetadata } = await import('../utils/task-status.js');
+    const metadata = getTaskMetadata(taskId);
+    console.log(chalk.bold('\nOpenSpec Change:'));
+    if (metadata.openspecChange) {
+        console.log(`  ${chalk.cyan(metadata.openspecChange)}`);
+    }
+    else {
+        console.log(chalk.gray('  Not linked (use --openspec when creating plan)'));
+    }
+    // Task status
+    const { getTaskStatus } = await import('../utils/task-status.js');
+    const status = getTaskStatus(taskId);
+    console.log(chalk.bold('\nStatus:'));
+    console.log(`  ${status}`);
+    console.log('─'.repeat(60));
+}
+//# sourceMappingURL=show.js.map

package/dist/commands/skills.d.ts

@@ -0,0 +1,3 @@
+import type { SkillsCommandOptions } from '../types.js';
+export declare function skillsCommand(action?: string, name?: string, options?: SkillsCommandOptions): void;
+//# sourceMappingURL=skills.d.ts.map