@tmddev/tmd 0.1.0

package/dist/utils/analysis.js

@@ -0,0 +1,159 @@
+/**
+ * Identify deviations from comparison results
+ */
+export function identifyDeviations(comparisons) {
+    const deviations = [];
+    for (const comparison of comparisons) {
+        if (comparison.status === 'met' || comparison.status === 'no-data') {
+            continue;
+        }
+        // Determine deviation type based on goal description
+        let type = 'scope';
+        const goalLower = comparison.goal.description.toLowerCase();
+        if (goalLower.includes('time') || goalLower.includes('deadline') || goalLower.includes('schedule')) {
+            type = 'timing';
+        }
+        else if (goalLower.includes('quality') || goalLower.includes('standard') || goalLower.includes('criteria')) {
+            type = 'quality';
+        }
+        else if (goalLower.includes('resource') || goalLower.includes('budget') || goalLower.includes('cost')) {
+            type = 'resources';
+        }
+        // Determine severity
+        let severity = 'minor';
+        if (comparison.status === 'unmet') {
+            if (comparison.deviationPercent && Math.abs(comparison.deviationPercent) > 50) {
+                severity = 'critical';
+            }
+            else {
+                severity = 'major';
+            }
+        }
+        else if (comparison.status === 'partial') {
+            severity = 'minor';
+        }
+        deviations.push({
+            comparison,
+            type,
+            severity,
+            description: `${comparison.goal.description}: ${comparison.status}`
+        });
+    }
+    return deviations;
+}
+/**
+ * Analyze root causes of deviations
+ */
+export function analyzeRootCauses(deviations) {
+    const rootCauses = [];
+    const patterns = new Map();
+    // Count deviation types
+    for (const deviation of deviations) {
+        const key = `${deviation.type}-${deviation.severity}`;
+        patterns.set(key, (patterns.get(key) ?? 0) + 1);
+    }
+    // Analyze patterns
+    const timingCount = deviations.filter(d => d.type === 'timing').length;
+    const scopeCount = deviations.filter(d => d.type === 'scope').length;
+    const qualityCount = deviations.filter(d => d.type === 'quality').length;
+    const resourceCount = deviations.filter(d => d.type === 'resources').length;
+    // Suggest root causes based on patterns
+    if (timingCount >= 2) {
+        rootCauses.push({
+            category: 'planning',
+            description: 'Multiple timing deviations suggest planning or scheduling issues',
+            evidence: deviations.filter(d => d.type === 'timing').map(d => d.description),
+            confidence: timingCount >= 3 ? 'high' : 'medium'
+        });
+    }
+    if (scopeCount >= 2) {
+        rootCauses.push({
+            category: 'execution',
+            description: 'Multiple scope deviations suggest execution or scope management issues',
+            evidence: deviations.filter(d => d.type === 'scope').map(d => d.description),
+            confidence: scopeCount >= 3 ? 'high' : 'medium'
+        });
+    }
+    if (qualityCount >= 1) {
+        rootCauses.push({
+            category: 'execution',
+            description: 'Quality deviations suggest quality control or process issues',
+            evidence: deviations.filter(d => d.type === 'quality').map(d => d.description),
+            confidence: qualityCount >= 2 ? 'high' : 'medium'
+        });
+    }
+    if (resourceCount >= 1) {
+        rootCauses.push({
+            category: 'resources',
+            description: 'Resource deviations suggest resource allocation or availability issues',
+            evidence: deviations.filter(d => d.type === 'resources').map(d => d.description),
+            confidence: resourceCount >= 2 ? 'high' : 'medium'
+        });
+    }
+    // If no clear pattern, suggest general planning issue
+    if (rootCauses.length === 0 && deviations.length > 0) {
+        rootCauses.push({
+            category: 'planning',
+            description: 'Multiple deviations suggest potential planning or estimation issues',
+            evidence: deviations.map(d => d.description),
+            confidence: 'low'
+        });
+    }
+    return rootCauses;
+}
+/**
+ * Recommend adjustments based on analysis
+ */
+export function recommendAdjustments(deviations, rootCauses) {
+    const recommendations = [];
+    const criticalDeviations = deviations.filter(d => d.severity === 'critical');
+    const majorDeviations = deviations.filter(d => d.severity === 'major');
+    // Immediate corrective actions for critical deviations
+    if (criticalDeviations.length > 0) {
+        recommendations.push({
+            priority: 'high',
+            category: 'corrective',
+            action: 'Address critical deviations immediately',
+            description: `Take immediate action to address ${String(criticalDeviations.length)} critical deviation(s). Review root causes and implement corrective measures.`
+        });
+    }
+    // Preventive measures for recurring issues
+    const timingRootCause = rootCauses.find(rc => rc.category === 'planning' && rc.description.includes('timing'));
+    if (timingRootCause) {
+        recommendations.push({
+            priority: 'medium',
+            category: 'preventive',
+            action: 'Improve planning and estimation processes',
+            description: 'Consider improving time estimation and planning processes to prevent future timing deviations.'
+        });
+    }
+    const executionRootCause = rootCauses.find(rc => rc.category === 'execution');
+    if (executionRootCause) {
+        recommendations.push({
+            priority: 'medium',
+            category: 'preventive',
+            action: 'Strengthen execution monitoring',
+            description: 'Implement better execution monitoring and control mechanisms to catch issues earlier.'
+        });
+    }
+    // Plan modifications
+    if (majorDeviations.length + criticalDeviations.length >= 3) {
+        recommendations.push({
+            priority: 'high',
+            category: 'plan-modification',
+            action: 'Review and adjust plan for next cycle',
+            description: 'Consider adjusting goals, timelines, or resource allocation in the next PDCA cycle based on current deviations.'
+        });
+    }
+    // If no critical issues, suggest minor improvements
+    if (recommendations.length === 0 && deviations.length > 0) {
+        recommendations.push({
+            priority: 'low',
+            category: 'plan-modification',
+            action: 'Review minor deviations for continuous improvement',
+            description: 'While no critical issues were found, review minor deviations to identify opportunities for improvement.'
+        });
+    }
+    return recommendations;
+}
+//# sourceMappingURL=analysis.js.map

package/dist/utils/comparison.d.ts

@@ -0,0 +1,34 @@
+export interface Goal {
+    description: string;
+    targetValue?: number | string;
+    deadline?: string;
+    criteria?: string;
+    index: number;
+    isQuantitative: boolean;
+}
+export interface Result {
+    value?: number | string;
+    description?: string;
+    source: 'execution' | 'data';
+    section?: string;
+}
+export interface ComparisonResult {
+    goal: Goal;
+    result?: Result;
+    status: 'met' | 'unmet' | 'over-achieved' | 'partial' | 'no-data';
+    deviation?: number;
+    deviationPercent?: number;
+}
+/**
+ * Extract goals from plan.md's Goals section
+ */
+export declare function extractGoals(planPath: string): Goal[];
+/**
+ * Extract results from execution.md and data.md
+ */
+export declare function extractResults(executionPath: string, dataPath: string): Result[];
+/**
+ * Compare goals with results
+ */
+export declare function compareGoalsAndResults(goals: Goal[], results: Result[]): ComparisonResult[];
+//# sourceMappingURL=comparison.d.ts.map

package/dist/utils/comparison.js

@@ -0,0 +1,217 @@
+import { readFileSync, existsSync } from 'fs';
+import yaml from 'js-yaml';
+/**
+ * Extract goals from plan.md's Goals section
+ */
+export function extractGoals(planPath) {
+    if (!existsSync(planPath)) {
+        return [];
+    }
+    const content = readFileSync(planPath, 'utf-8');
+    const lines = content.split('\n');
+    const goals = [];
+    let inGoalsSection = false;
+    let goalIndex = 0;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (!line)
+            continue;
+        const trimmed = line.trim();
+        // Detect Goals section header
+        if (trimmed.startsWith('##') && trimmed.toLowerCase().includes('goals')) {
+            inGoalsSection = true;
+            continue;
+        }
+        // Stop at next section (## header)
+        if (inGoalsSection && trimmed.startsWith('##') && !trimmed.toLowerCase().includes('goals')) {
+            break;
+        }
+        // Parse goal items
+        if (inGoalsSection) {
+            // Support both checkbox and bullet formats
+            const goalMatch = trimmed.match(/^-\s+(?:\[([ x])\]\s+)?(.+)$/);
+            if (goalMatch?.[2]) {
+                const goalText = goalMatch[2];
+                // Try to extract quantitative values (numbers, percentages)
+                const numberMatch = goalText.match(/(\d+(?:\.\d+)?)\s*(%|seconds?|minutes?|hours?|days?|weeks?|months?|years?|ms|kb|mb|gb|times?|x)/i);
+                const targetValue = numberMatch?.[1] ? parseFloat(numberMatch[1]) : undefined;
+                const isQuantitative = !!targetValue;
+                // Try to extract deadline (dates, timeframes)
+                const deadlineMatch = goalText.match(/(?:by|before|within|deadline:?)\s+([^\n,]+)/i);
+                const deadline = deadlineMatch?.[1] ? deadlineMatch[1].trim() : undefined;
+                const goal = {
+                    description: goalText,
+                    index: goalIndex++,
+                    isQuantitative
+                };
+                if (targetValue !== undefined) {
+                    goal.targetValue = targetValue;
+                }
+                if (deadline !== undefined) {
+                    goal.deadline = deadline;
+                }
+                goals.push(goal);
+            }
+        }
+    }
+    return goals;
+}
+/**
+ * Extract results from execution.md and data.md
+ */
+export function extractResults(executionPath, dataPath) {
+    const results = [];
+    // Extract from execution.md
+    if (existsSync(executionPath)) {
+        const executionContent = readFileSync(executionPath, 'utf-8');
+        // Extract from Actions Taken section
+        const actionsMatch = executionContent.match(/## Actions Taken\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (actionsMatch?.[1]) {
+            const actions = actionsMatch[1].trim();
+            if (actions) {
+                results.push({
+                    description: actions,
+                    source: 'execution',
+                    section: 'Actions Taken'
+                });
+            }
+        }
+        // Extract from Data Collected section
+        const dataMatch = executionContent.match(/## Data Collected\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (dataMatch?.[1]) {
+            const data = dataMatch[1].trim();
+            if (data) {
+                // Try to extract numbers from data
+                const numberMatch = data.match(/(\d+(?:\.\d+)?)/);
+                const value = numberMatch?.[1] ? parseFloat(numberMatch[1]) : undefined;
+                const result = {
+                    description: data,
+                    source: 'execution',
+                    section: 'Data Collected'
+                };
+                if (value !== undefined) {
+                    result.value = value;
+                }
+                results.push(result);
+            }
+        }
+        // Extract from Observations section
+        const observationsMatch = executionContent.match(/## Observations\s*\n([\s\S]*?)(?=\n##|$)/i);
+        if (observationsMatch?.[1]) {
+            const observations = observationsMatch[1].trim();
+            if (observations) {
+                results.push({
+                    description: observations,
+                    source: 'execution',
+                    section: 'Observations'
+                });
+            }
+        }
+    }
+    // Extract from data.md (structured format)
+    if (existsSync(dataPath)) {
+        try {
+            const dataContent = readFileSync(dataPath, 'utf-8');
+            // Try to parse as YAML
+            try {
+                const data = yaml.load(dataContent);
+                for (const [key, value] of Object.entries(data)) {
+                    results.push({
+                        value: typeof value === 'number' ? value : String(value),
+                        description: `${key}: ${String(value)}`,
+                        source: 'data',
+                        section: key
+                    });
+                }
+            }
+            catch {
+                // Not YAML, try to parse as key-value pairs
+                const lines = dataContent.split('\n');
+                for (const line of lines) {
+                    const kvMatch = line.match(/^-\s*([^:]+):\s*(.+)$/);
+                    if (kvMatch?.[1] && kvMatch[2]) {
+                        const key = kvMatch[1].trim();
+                        const value = kvMatch[2].trim();
+                        const numValue = parseFloat(value);
+                        const resultValue = isNaN(numValue) ? value : numValue;
+                        results.push({
+                            value: resultValue,
+                            description: `${key}: ${typeof resultValue === 'number' ? String(resultValue) : resultValue}`,
+                            source: 'data',
+                            section: key
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // Ignore parsing errors
+        }
+    }
+    return results;
+}
+/**
+ * Compare goals with results
+ */
+export function compareGoalsAndResults(goals, results) {
+    const comparisons = [];
+    for (const goal of goals) {
+        let matchedResult;
+        let status = 'no-data';
+        // Try to match goal with results
+        // Simple matching: look for similar keywords or values
+        if (goal.isQuantitative && goal.targetValue !== undefined) {
+            // For quantitative goals, try to find matching numeric values
+            for (const result of results) {
+                if (result.value !== undefined && typeof result.value === 'number') {
+                    const goalValue = typeof goal.targetValue === 'number'
+                        ? goal.targetValue
+                        : parseFloat(typeof goal.targetValue === 'string' ? goal.targetValue : '0');
+                    if (!isNaN(goalValue)) {
+                        // Found a numeric result, use it
+                        matchedResult = result;
+                        const deviation = result.value - goalValue;
+                        const deviationPercent = (deviation / goalValue) * 100;
+                        if (Math.abs(deviationPercent) < 5) {
+                            status = 'met';
+                        }
+                        else if (deviationPercent > 0) {
+                            status = 'over-achieved';
+                        }
+                        else if (Math.abs(deviationPercent) < 50) {
+                            status = 'partial';
+                        }
+                        else {
+                            status = 'unmet';
+                        }
+                        comparisons.push({
+                            goal,
+                            result: matchedResult,
+                            status,
+                            deviation,
+                            deviationPercent
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        else {
+            // For qualitative goals, check if there's any result
+            if (results.length > 0) {
+                matchedResult = results[0]; // Use first available result
+                // Simple heuristic: if there's a result, assume partial or met
+                status = 'partial';
+            }
+        }
+        // If no match found, mark as no-data
+        if (!matchedResult) {
+            comparisons.push({
+                goal,
+                status: 'no-data'
+            });
+        }
+    }
+    return comparisons;
+}
+//# sourceMappingURL=comparison.js.map

package/dist/utils/language-validator.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Language validation utilities
+ * Ensures all documents use English as per specification
+ */
+export declare function detectLanguage(text: string): 'en' | 'non-en';
+export declare function validateEnglish(text: string): {
+    isValid: boolean;
+    warnings: string[];
+};
+export declare function warnIfNonEnglish(text: string, context?: string): void;
+//# sourceMappingURL=language-validator.d.ts.map

package/dist/utils/language-validator.js

@@ -0,0 +1,39 @@
+/**
+ * Language validation utilities
+ * Ensures all documents use English as per specification
+ */
+export function detectLanguage(text) {
+    // Simple heuristic: check for common non-English characters
+    // This is a basic implementation - can be enhanced with proper language detection library
+    const nonEnglishPatterns = [
+        /[\u4e00-\u9fff]/, // Chinese
+        /[\u3040-\u309f\u30a0-\u30ff]/, // Japanese
+        /[\u0400-\u04ff]/, // Cyrillic
+        /[\u0600-\u06ff]/, // Arabic
+        /[\u0590-\u05ff]/, // Hebrew
+    ];
+    for (const pattern of nonEnglishPatterns) {
+        if (pattern.test(text)) {
+            return 'non-en';
+        }
+    }
+    return 'en';
+}
+export function validateEnglish(text) {
+    const warnings = [];
+    const language = detectLanguage(text);
+    if (language === 'non-en') {
+        warnings.push('Non-English content detected. All documents should use English.');
+    }
+    return {
+        isValid: language === 'en',
+        warnings
+    };
+}
+export function warnIfNonEnglish(text, context = 'document') {
+    const validation = validateEnglish(text);
+    if (!validation.isValid) {
+        console.warn(`⚠ Warning: ${validation.warnings.join(', ')} (${context})`);
+    }
+}
+//# sourceMappingURL=language-validator.js.map

package/dist/utils/openspec.d.ts

@@ -0,0 +1,5 @@
+export declare function isOpenSpecProject(): boolean;
+export declare function generateChangeId(description: string): string;
+export declare function createOpenSpecChange(description: string, taskId: string): string | null;
+export declare function linkOpenSpecChange(taskId: string, changeId: string): boolean;
+//# sourceMappingURL=openspec.d.ts.map

package/dist/utils/openspec.js

@@ -0,0 +1,91 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+const OPENSPEC_DIR = 'openspec';
+const CHANGES_DIR = join(OPENSPEC_DIR, 'changes');
+export function isOpenSpecProject() {
+    return existsSync(OPENSPEC_DIR) && existsSync(join(OPENSPEC_DIR, 'project.md'));
+}
+export function generateChangeId(description) {
+    // Generate OpenSpec-compatible change-id
+    const desc = description
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '')
+        .substring(0, 50);
+    // OpenSpec uses verb-led format
+    return `add-${desc}`;
+}
+export function createOpenSpecChange(description, taskId) {
+    if (!isOpenSpecProject()) {
+        console.log(chalk.yellow('  OpenSpec project not detected'));
+        return null;
+    }
+    const changeId = generateChangeId(description);
+    const changeDir = join(CHANGES_DIR, changeId);
+    if (!existsSync(changeDir)) {
+        mkdirSync(changeDir, { recursive: true });
+        mkdirSync(join(changeDir, 'specs'), { recursive: true });
+    }
+    // Create proposal.md
+    const proposalContent = `# Change: ${description}
+
+## Why
+<!-- Describe the problem or opportunity -->
+
+## What Changes
+- <!-- List changes -->
+
+## Impact
+- Affected specs: <!-- List capabilities -->
+- Affected code: <!-- List files/systems -->
+- TMD Task: ${taskId}
+`;
+    writeFileSync(join(changeDir, 'proposal.md'), proposalContent);
+    // Create tasks.md
+    const tasksContent = `# Implementation Tasks
+
+## 1. Implementation
+- [ ] <!-- Add tasks -->
+`;
+    writeFileSync(join(changeDir, 'tasks.md'), tasksContent);
+    // Link TMD task to OpenSpec change
+    const metadataPath = join('tmd', 'plan', taskId, 'metadata.json');
+    if (existsSync(metadataPath)) {
+        const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
+        metadata['openspecChange'] = changeId;
+        writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    console.log(chalk.green(`  Created OpenSpec change: ${changeId}`));
+    console.log(chalk.blue(`    Directory: ${changeDir}`));
+    return changeId;
+}
+export function linkOpenSpecChange(taskId, changeId) {
+    if (!isOpenSpecProject()) {
+        return false;
+    }
+    const changeDir = join(CHANGES_DIR, changeId);
+    if (!existsSync(changeDir)) {
+        console.log(chalk.red(`  OpenSpec change not found: ${changeId}`));
+        return false;
+    }
+    // Link in task metadata
+    const metadataPath = join('tmd', 'plan', taskId, 'metadata.json');
+    if (existsSync(metadataPath)) {
+        const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
+        metadata['openspecChange'] = changeId;
+        writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    // Link in OpenSpec change proposal
+    const proposalPath = join(changeDir, 'proposal.md');
+    if (existsSync(proposalPath)) {
+        const content = readFileSync(proposalPath, 'utf-8');
+        if (!content.includes(`TMD Task: ${taskId}`)) {
+            const updated = content.replace(/## Impact\n/, `## Impact\n- TMD Task: ${taskId}\n`);
+            writeFileSync(proposalPath, updated);
+        }
+    }
+    console.log(chalk.green(`  Linked to OpenSpec change: ${changeId}`));
+    return true;
+}
+//# sourceMappingURL=openspec.js.map

package/dist/utils/paths.d.ts

@@ -0,0 +1,10 @@
+export declare function getTmdDir(): string;
+export declare function getTaskDir(phase: string, taskId: string): string;
+export declare function ensureDir(path: string): void;
+export declare function getPlanDir(taskId: string): string;
+export declare function getDoDir(taskId: string): string;
+export declare function getCheckDir(taskId: string): string;
+export declare function getActDir(taskId: string): string;
+export declare function getSkillsDir(): string;
+export declare function getSkillDir(skillName: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/utils/paths.js

@@ -0,0 +1,33 @@
+import { join } from 'path';
+import { existsSync, mkdirSync } from 'fs';
+const TMD_DIR = 'tmd';
+export function getTmdDir() {
+    return TMD_DIR;
+}
+export function getTaskDir(phase, taskId) {
+    return join(TMD_DIR, phase, taskId);
+}
+export function ensureDir(path) {
+    if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+    }
+}
+export function getPlanDir(taskId) {
+    return getTaskDir('plan', taskId);
+}
+export function getDoDir(taskId) {
+    return getTaskDir('do', taskId);
+}
+export function getCheckDir(taskId) {
+    return getTaskDir('check', taskId);
+}
+export function getActDir(taskId) {
+    return getTaskDir('act', taskId);
+}
+export function getSkillsDir() {
+    return join(TMD_DIR, 'skills');
+}
+export function getSkillDir(skillName) {
+    return join(getSkillsDir(), skillName);
+}
+//# sourceMappingURL=paths.js.map

package/dist/utils/skills.d.ts

@@ -0,0 +1,3 @@
+export declare function createSkill(description: string, taskId: string): string | null;
+export declare function executeSkill(skillName: string, _taskId: string, parallel?: boolean, maxConcurrency?: number): Promise<void>;
+//# sourceMappingURL=skills.d.ts.map