@tmddev/tmd 0.1.0

package/dist/cli.js

@@ -0,0 +1,92 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'module';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { planCommand } from './commands/plan.js';
+import { doCommand } from './commands/do.js';
+import { checkCommand } from './commands/check.js';
+import { actCommand } from './commands/act.js';
+import { listCommand } from './commands/list.js';
+import { showCommand } from './commands/show.js';
+import { skillsCommand } from './commands/skills.js';
+const program = new Command();
+// Use fileURLToPath to resolve package.json relative to project root
+// When running from bin/tmd.js -> dist/cli.js, we need to go up from dist/ to project root
+const require = createRequire(import.meta.url);
+const __filename = fileURLToPath(import.meta.url);
+// dist/cli.js -> dist/ -> project root
+const projectRoot = dirname(dirname(__filename));
+const packageJsonPath = join(projectRoot, 'package.json');
+const pkg = require(packageJsonPath);
+const { version } = pkg;
+program
+    .name('tmd')
+    .description('Task Markdown Driven - PDCA cycle management framework')
+    .version(version);
+// PDCA commands
+program
+    .command('plan')
+    .alias('p')
+    .description('Plan phase: Define objectives, analyze problems, and create plans')
+    .argument('<description>', 'Task description')
+    .option('--openspec', 'Create or link OpenSpec change proposal')
+    .option('--skill', 'Create skill definition')
+    .option('--use-skill <skill-name>', 'Use existing skill')
+    .option('--validate-tasks', 'Validate task size: pee-break (10 seconds to 10 minutes)')
+    .action(planCommand);
+program
+    .command('do')
+    .alias('d')
+    .description('Do phase: Execute actions and collect data')
+    .argument('<task-id>', 'Task ID')
+    .option('--data <key=value>', 'Record data')
+    .option('--skill <skill-name>', 'Execute skill')
+    .option('--list', 'Show task status without modifying')
+    .option('--task <index>', 'Mark task at index as complete', (value) => parseInt(value, 10))
+    .option('--parallel', 'Enable concurrent execution of independent tasks')
+    .option('--max-concurrency <n>', 'Maximum number of concurrent operations', (value) => parseInt(value, 10))
+    .action(doCommand);
+program
+    .command('check')
+    .alias('c')
+    .description('Check phase: Evaluate results and analyze deviations')
+    .argument('<task-id>', 'Task ID')
+    .option('--compare', 'Automatic comparison (default behavior)')
+    .option('--analyze', 'Perform root cause analysis')
+    .option('--recommend', 'Generate adjustment recommendations')
+    .option('--manual', 'Manual mode (disable automatic comparison)')
+    .option('--validate-skill', 'Validate skill execution')
+    .action(checkCommand);
+program
+    .command('act')
+    .alias('a')
+    .description('Act phase: Take improvement actions and standardize')
+    .argument('<task-id>', 'Task ID')
+    .option('--standardize', 'Automatically identify and document successful practices')
+    .option('--carry-forward', 'Generate next cycle planning items for unresolved issues')
+    .option('--manual', 'Manual mode (disable automatic processing)')
+    .option('--complete', 'Mark task as completed')
+    .action(actCommand);
+// Task management commands
+program
+    .command('list')
+    .description('List all tasks')
+    .option('--status <status>', 'Filter by status')
+    .option('--phase <phase>', 'Filter by phase')
+    .action(listCommand);
+program
+    .command('show')
+    .description('Show task details')
+    .argument('<task-id>', 'Task ID')
+    .action(showCommand);
+// Skills commands
+program
+    .command('skills')
+    .description('Manage skills')
+    .argument('[action]', 'Action: list, search, show, invoke')
+    .argument('[name]', 'Skill name or search query')
+    .option('--input <params>', 'Input parameters for invoke')
+    .action(skillsCommand);
+program.parse();
+//# sourceMappingURL=cli.js.map

package/dist/commands/act.d.ts

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

package/dist/commands/act.js

@@ -0,0 +1,210 @@
+import { existsSync } from 'fs';
+import { ensureDir, getActDir, getCheckDir } from '../utils/paths.js';
+import { improvementTemplate, standardizationTemplate, renderTemplate } from '../utils/templates.js';
+import { updateTaskStatus } from '../utils/task-status.js';
+import { parseEvaluationResults, parseDeviationAnalysis, identifySuccesses, identifyFailures, identifyUnresolvedIssues } from '../utils/act-processing.js';
+import { extractSuccessfulPractices, generateStandardizationRecommendations, formatStandardizationDocument } from '../utils/standardization.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+function generateImprovementDocument(failures, taskId) {
+    let content = renderTemplate(improvementTemplate, { taskId });
+    // Add corrective actions
+    const criticalFailures = failures.filter(f => f.severity === 'critical');
+    const majorFailures = failures.filter(f => f.severity === 'major');
+    const minorFailures = failures.filter(f => f.severity === 'minor');
+    if (failures.length > 0) {
+        content += '\n## Corrective Actions\n\n';
+        if (criticalFailures.length > 0) {
+            content += '### Immediate Actions (Critical)\n\n';
+            for (const failure of criticalFailures) {
+                content += `- **${failure.goal}**: ${failure.lesson ?? failure.deviation}\n`;
+                if (failure.rootCause) {
+                    content += `  - Root cause: ${failure.rootCause}\n`;
+                }
+                content += '\n';
+            }
+        }
+        if (majorFailures.length > 0) {
+            content += '### Short-term Fixes (Major)\n\n';
+            for (const failure of majorFailures) {
+                content += `- **${failure.goal}**: ${failure.lesson ?? failure.deviation}\n`;
+                if (failure.rootCause) {
+                    content += `  - Root cause: ${failure.rootCause}\n`;
+                }
+                content += '\n';
+            }
+        }
+        if (minorFailures.length > 0) {
+            content += '### Long-term Improvements (Minor)\n\n';
+            for (const failure of minorFailures) {
+                content += `- **${failure.goal}**: ${failure.lesson ?? failure.deviation}\n\n`;
+            }
+        }
+    }
+    // Add preventive measures
+    const rootCauses = new Set(failures.map(f => f.rootCause).filter(Boolean));
+    if (rootCauses.size > 0) {
+        content += '\n## Preventive Measures\n\n';
+        content += 'Based on root cause analysis, the following preventive measures are recommended:\n\n';
+        for (const rootCause of rootCauses) {
+            if (rootCause) {
+                content += `### ${rootCause}\n\n`;
+                content += '- Implement process improvements to prevent similar failures\n';
+                content += '- Establish early warning indicators\n';
+                content += '- Add process controls to maintain quality\n';
+                content += '- Consider training or knowledge sharing\n\n';
+            }
+        }
+    }
+    // Add lessons learned
+    if (failures.length > 0) {
+        content += '\n## Lessons Learned\n\n';
+        content += `### Summary of Failures\n\n`;
+        content += `Total failures encountered: ${String(failures.length)}\n`;
+        content += `- Critical: ${String(criticalFailures.length)}\n`;
+        content += `- Major: ${String(majorFailures.length)}\n`;
+        content += `- Minor: ${String(minorFailures.length)}\n\n`;
+        content += `### Failure Patterns\n\n`;
+        const byType = {};
+        for (const failure of failures) {
+            const type = failure.deviation.split(':')[0] ?? 'unknown';
+            byType[type] = (byType[type] ?? 0) + 1;
+        }
+        for (const [type, count] of Object.entries(byType)) {
+            content += `- ${type}: ${String(count)} occurrence(s)\n`;
+        }
+        content += '\n';
+        content += `### Key Lessons\n\n`;
+        for (const failure of failures) {
+            if (failure.lesson) {
+                content += `- ${failure.lesson}\n`;
+            }
+        }
+        content += '\n';
+    }
+    return content;
+}
+function generateNextCycleItems(unresolvedIssues, taskId) {
+    let content = `# Next Cycle Planning Items\n\n`;
+    content += `Items identified from task ${taskId} that need to be addressed in the next PDCA cycle.\n\n`;
+    if (unresolvedIssues.length === 0) {
+        content += 'No unresolved issues identified. All goals were achieved or can be addressed in current cycle.\n';
+        return content;
+    }
+    content += `## Unresolved Issues\n\n`;
+    content += `Total unresolved issues: ${String(unresolvedIssues.length)}\n\n`;
+    // Group by priority
+    const byPriority = {
+        high: unresolvedIssues.filter(i => i.priority === 'high'),
+        medium: unresolvedIssues.filter(i => i.priority === 'medium'),
+        low: unresolvedIssues.filter(i => i.priority === 'low')
+    };
+    for (const priority of ['high', 'medium', 'low']) {
+        if (byPriority[priority].length > 0) {
+            const priorityLabel = priority.charAt(0).toUpperCase() + priority.slice(1);
+            const emoji = priority === 'high' ? '🔴' : priority === 'medium' ? '🟡' : '🟢';
+            content += `### ${emoji} ${priorityLabel} Priority\n\n`;
+            for (const issue of byPriority[priority]) {
+                content += `#### ${issue.goal}\n\n`;
+                content += `**Description**: ${issue.description}\n\n`;
+                content += `**Reason**: ${issue.reason}\n\n`;
+                if (issue.linkToDeviation) {
+                    content += `**Related Deviation**: ${issue.linkToDeviation}\n\n`;
+                }
+                content += `**Next Cycle Action**: Create new plan to address: ${issue.goal}\n\n`;
+            }
+        }
+    }
+    content += `## Planning Items for Next Cycle\n\n`;
+    content += `Use these items when creating the next PDCA cycle plan:\n\n`;
+    for (const issue of unresolvedIssues) {
+        content += `- [ ] ${issue.description} (Priority: ${issue.priority})\n`;
+    }
+    return content;
+}
+export function actCommand(taskId, options) {
+    // Validate check exists
+    const evaluationPath = join(getCheckDir(taskId), 'evaluation.md');
+    const deviationPath = join(getCheckDir(taskId), 'deviation.md');
+    if (!existsSync(evaluationPath)) {
+        console.error(chalk.red(`✗ Check results not found for task: ${taskId}`));
+        console.error(chalk.yellow(`  Run 'tmd check ${taskId}' first to generate evaluation results.`));
+        process.exit(1);
+    }
+    const actDir = getActDir(taskId);
+    ensureDir(actDir);
+    // Determine if automatic processing should run (default unless --manual)
+    const shouldProcess = !options.manual;
+    let improvementContent = renderTemplate(improvementTemplate, { taskId });
+    let standardizationContent = '';
+    let nextCycleContent = '';
+    let successes = [];
+    let failures = [];
+    let unresolvedIssues = [];
+    // Automatic processing
+    if (shouldProcess) {
+        // Parse check results
+        const evaluationResults = parseEvaluationResults(evaluationPath);
+        const deviationAnalysis = existsSync(deviationPath)
+            ? parseDeviationAnalysis(deviationPath)
+            : { deviations: [], rootCauses: [] };
+        // Identify successes and failures
+        successes = identifySuccesses(evaluationResults);
+        failures = identifyFailures(deviationAnalysis, evaluationResults);
+        unresolvedIssues = identifyUnresolvedIssues(evaluationResults, deviationAnalysis);
+        // Generate improvement document with processed results
+        improvementContent = generateImprovementDocument(failures, taskId);
+        // Generate standardization if requested or if successes found
+        if (options.standardize || successes.length > 0) {
+            const practices = extractSuccessfulPractices(successes);
+            const recommendations = generateStandardizationRecommendations(practices);
+            standardizationContent = formatStandardizationDocument(practices, recommendations);
+        }
+        else {
+            standardizationContent = renderTemplate(standardizationTemplate, { taskId });
+        }
+        // Generate next cycle items if requested or if unresolved issues found
+        if (options.carryForward || unresolvedIssues.length > 0) {
+            nextCycleContent = generateNextCycleItems(unresolvedIssues, taskId);
+        }
+        // Display summary
+        console.log(chalk.blue('\n  Processing Summary:'));
+        console.log(chalk.green(`    Successful practices identified: ${String(successes.length)}`));
+        console.log(chalk.red(`    Failures and lessons learned: ${String(failures.length)}`));
+        if (unresolvedIssues.length > 0) {
+            console.log(chalk.yellow(`    Unresolved issues for next cycle: ${String(unresolvedIssues.length)}`));
+        }
+        if (options.standardize && successes.length > 0) {
+            console.log(chalk.blue(`    Standardization recommendations: ${String(successes.length)}`));
+        }
+    }
+    else {
+        // Manual mode - just create templates
+        standardizationContent = renderTemplate(standardizationTemplate, { taskId });
+    }
+    // Write documents
+    writeFileSync(join(actDir, 'improvement.md'), improvementContent);
+    if (options.standardize || (shouldProcess && successes.length > 0)) {
+        writeFileSync(join(actDir, 'standardization.md'), standardizationContent);
+    }
+    if (options.carryForward || (shouldProcess && unresolvedIssues.length > 0)) {
+        writeFileSync(join(actDir, 'next-cycle-items.md'), nextCycleContent);
+    }
+    // Update task status
+    updateTaskStatus(taskId, 'acting');
+    console.log(chalk.green(`\n✓ Started act phase for task: ${taskId}`));
+    console.log(chalk.blue(`  Directory: ${actDir}`));
+    console.log(chalk.blue(`  Improvement: ${join(actDir, 'improvement.md')}`));
+    if (existsSync(join(actDir, 'standardization.md'))) {
+        console.log(chalk.blue(`  Standardization: ${join(actDir, 'standardization.md')}`));
+    }
+    if (existsSync(join(actDir, 'next-cycle-items.md'))) {
+        console.log(chalk.blue(`  Next Cycle Items: ${join(actDir, 'next-cycle-items.md')}`));
+    }
+    if (options.complete) {
+        updateTaskStatus(taskId, 'completed');
+        console.log(chalk.green(`  Task marked as completed`));
+    }
+}
+//# sourceMappingURL=act.js.map

package/dist/commands/check.d.ts

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

package/dist/commands/check.js

@@ -0,0 +1,183 @@
+import { existsSync } from 'fs';
+import { ensureDir, getCheckDir, getPlanDir, getDoDir } from '../utils/paths.js';
+import { evaluationTemplate, renderTemplate } from '../utils/templates.js';
+import { updateTaskStatus } from '../utils/task-status.js';
+import { extractGoals, extractResults, compareGoalsAndResults } from '../utils/comparison.js';
+import { identifyDeviations, analyzeRootCauses, recommendAdjustments } from '../utils/analysis.js';
+import { writeFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+function generateComparisonTable(comparisons) {
+    let table = '\n## Comparison with Plan\n\n';
+    table += '| Goal | Planned Value | Actual Value | Status | Deviation |\n';
+    table += '|------|---------------|--------------|--------|-----------|\n';
+    for (const comp of comparisons) {
+        const goal = comp.goal.description.substring(0, 50) + (comp.goal.description.length > 50 ? '...' : '');
+        const planned = comp.goal.targetValue !== undefined ? String(comp.goal.targetValue) : 'N/A';
+        const actual = comp.result?.value !== undefined ? String(comp.result.value) : (comp.result?.description?.substring(0, 30) ?? 'No data');
+        const status = comp.status === 'met' ? '✅ Met' :
+            comp.status === 'unmet' ? '❌ Unmet' :
+                comp.status === 'over-achieved' ? '📈 Over-achieved' :
+                    comp.status === 'partial' ? '⚠️ Partial' : '❓ No Data';
+        const deviation = comp.deviation !== undefined ?
+            `${comp.deviation > 0 ? '+' : ''}${comp.deviation.toFixed(2)}${comp.deviationPercent !== undefined ? ` (${comp.deviationPercent > 0 ? '+' : ''}${comp.deviationPercent.toFixed(1)}%)` : ''}` :
+            'N/A';
+        table += `| ${goal} | ${planned} | ${actual} | ${status} | ${deviation} |\n`;
+    }
+    return table;
+}
+function generateDeviationAnalysis(deviations) {
+    if (deviations.length === 0) {
+        return '\n## Deviations Identified\n\nNo deviations found. All goals were met.\n';
+    }
+    let analysis = '\n## Deviations Identified\n\n';
+    for (const deviation of deviations) {
+        analysis += `### ${deviation.description}\n\n`;
+        analysis += `- **Type**: ${deviation.type}\n`;
+        analysis += `- **Severity**: ${deviation.severity}\n`;
+        analysis += `- **Status**: ${deviation.comparison.status}\n`;
+        if (deviation.comparison.deviation !== undefined) {
+            analysis += `- **Deviation**: ${String(deviation.comparison.deviation)}\n`;
+        }
+        analysis += '\n';
+    }
+    return analysis;
+}
+function generateRootCauseAnalysis(rootCauses) {
+    if (rootCauses.length === 0) {
+        return '\n## Root Cause Analysis\n\nNo clear root causes identified.\n';
+    }
+    let analysis = '\n## Root Cause Analysis\n\n';
+    for (const cause of rootCauses) {
+        analysis += `### ${cause.category.charAt(0).toUpperCase() + cause.category.slice(1)} Issues\n\n`;
+        analysis += `${cause.description}\n\n`;
+        analysis += `**Confidence**: ${cause.confidence}\n\n`;
+        if (cause.evidence.length > 0) {
+            analysis += `**Evidence**:\n`;
+            for (const evidence of cause.evidence) {
+                analysis += `- ${evidence}\n`;
+            }
+            analysis += '\n';
+        }
+    }
+    return analysis;
+}
+function generateRecommendations(recommendations) {
+    if (recommendations.length === 0) {
+        return '\n## Recommendations\n\nNo specific recommendations at this time.\n';
+    }
+    let recs = '\n## Recommendations\n\n';
+    const byPriority = {
+        high: recommendations.filter(r => r.priority === 'high'),
+        medium: recommendations.filter(r => r.priority === 'medium'),
+        low: recommendations.filter(r => r.priority === 'low')
+    };
+    for (const priority of ['high', 'medium', 'low']) {
+        if (byPriority[priority].length > 0) {
+            recs += `### ${priority.charAt(0).toUpperCase() + priority.slice(1)} Priority\n\n`;
+            for (const rec of byPriority[priority]) {
+                recs += `- **${rec.action}** (${rec.category})\n`;
+                recs += `  ${rec.description}\n\n`;
+            }
+        }
+    }
+    return recs;
+}
+export function checkCommand(taskId, options) {
+    // Validate plan and execution exist
+    const planPath = join(getPlanDir(taskId), 'plan.md');
+    const executionPath = join(getDoDir(taskId), 'execution.md');
+    const dataPath = join(getDoDir(taskId), 'data.md');
+    if (!existsSync(planPath)) {
+        console.error(chalk.red(`✗ Plan not found for task: ${taskId}`));
+        process.exit(1);
+    }
+    if (!existsSync(executionPath)) {
+        console.error(chalk.red(`✗ Execution not found for task: ${taskId}`));
+        process.exit(1);
+    }
+    const checkDir = getCheckDir(taskId);
+    ensureDir(checkDir);
+    // Determine if automatic comparison should run (default unless --manual)
+    const shouldCompare = !options.manual;
+    let evaluationContent = renderTemplate(evaluationTemplate, { taskId });
+    let deviationContent = '# Deviation Analysis\n\n';
+    // Automatic comparison and analysis
+    if (shouldCompare) {
+        // Extract goals and results
+        const goals = extractGoals(planPath);
+        const results = extractResults(executionPath, dataPath);
+        if (goals.length === 0) {
+            console.log(chalk.yellow('  ⚠ No goals found in plan.md. Add goals to enable automatic comparison.'));
+        }
+        else {
+            // Perform comparison
+            const comparisons = compareGoalsAndResults(goals, results);
+            // Generate comparison table
+            evaluationContent += generateComparisonTable(comparisons);
+            // Calculate summary statistics
+            const totalGoals = comparisons.length;
+            const metGoals = comparisons.filter(c => c.status === 'met').length;
+            const unmetGoals = comparisons.filter(c => c.status === 'unmet').length;
+            const successRate = totalGoals > 0 ? Math.round((metGoals / totalGoals) * 100) : 0;
+            // Display summary
+            console.log(chalk.blue('\n  Comparison Summary:'));
+            console.log(chalk.gray(`    Total goals: ${String(totalGoals)}`));
+            console.log(chalk.green(`    Goals met: ${String(metGoals)}`));
+            if (unmetGoals > 0) {
+                console.log(chalk.red(`    Goals unmet: ${String(unmetGoals)}`));
+            }
+            console.log(chalk.blue(`    Success rate: ${String(successRate)}%`));
+            // Identify deviations
+            const deviations = identifyDeviations(comparisons);
+            const criticalDeviations = deviations.filter(d => d.severity === 'critical').length;
+            if (criticalDeviations > 0) {
+                console.log(chalk.red(`    Critical deviations: ${String(criticalDeviations)}`));
+            }
+            // Generate deviation analysis
+            deviationContent += generateDeviationAnalysis(deviations);
+            // Root cause analysis
+            if (options.analyze && deviations.length > 0) {
+                const rootCauses = analyzeRootCauses(deviations);
+                deviationContent += generateRootCauseAnalysis(rootCauses);
+                console.log(chalk.blue(`\n  Root Cause Analysis:`));
+                for (const cause of rootCauses) {
+                    console.log(chalk.gray(`    ${cause.category}: ${cause.description}`));
+                }
+            }
+            // Recommendations
+            if (options.recommend && deviations.length > 0) {
+                const rootCauses = options.analyze ? analyzeRootCauses(deviations) : [];
+                const recommendations = recommendAdjustments(deviations, rootCauses);
+                evaluationContent += generateRecommendations(recommendations);
+                console.log(chalk.blue(`\n  Recommendations:`));
+                for (const rec of recommendations.filter(r => r.priority === 'high')) {
+                    console.log(chalk.yellow(`    [${rec.priority.toUpperCase()}] ${rec.action}`));
+                }
+            }
+            // Add summary to evaluation
+            evaluationContent += `\n## Results Summary\n\n`;
+            evaluationContent += `- Total goals: ${String(totalGoals)}\n`;
+            evaluationContent += `- Goals met: ${String(metGoals)}\n`;
+            evaluationContent += `- Goals unmet: ${String(unmetGoals)}\n`;
+            evaluationContent += `- Success rate: ${String(successRate)}%\n`;
+            if (criticalDeviations > 0) {
+                evaluationContent += `- Critical deviations: ${String(criticalDeviations)}\n`;
+            }
+        }
+    }
+    writeFileSync(join(checkDir, 'evaluation.md'), evaluationContent);
+    writeFileSync(join(checkDir, 'deviation.md'), deviationContent);
+    // Update task status
+    updateTaskStatus(taskId, 'checking');
+    console.log(chalk.green(`\n✓ Started check phase for task: ${taskId}`));
+    console.log(chalk.blue(`  Directory: ${checkDir}`));
+    console.log(chalk.blue(`  Evaluation: ${join(checkDir, 'evaluation.md')}`));
+    console.log(chalk.blue(`  Deviation Analysis: ${join(checkDir, 'deviation.md')}`));
+    // Skill validation
+    if (options.validateSkill) {
+        console.log(chalk.yellow('  Skill validation: Basic validation implemented'));
+        // TODO: Full skill validation
+    }
+}
+//# sourceMappingURL=check.js.map

package/dist/commands/do.d.ts

@@ -0,0 +1,3 @@
+import type { DoCommandOptions } from '../types.js';
+export declare function doCommand(taskId: string, options: DoCommandOptions): Promise<void>;
+//# sourceMappingURL=do.d.ts.map