@tmddev/tmd 0.1.0

package/dist/commands/skills.js

@@ -0,0 +1,243 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { getSkillsDir, getSkillDir } from '../utils/paths.js';
+import { join } from 'path';
+import chalk from 'chalk';
+import yaml from 'js-yaml';
+import { addSkillFromSkillssh } from '../utils/skillssh.js';
+export function skillsCommand(action, name, options) {
+    const skillsDir = getSkillsDir();
+    if (!action || action === 'list') {
+        listSkills(skillsDir);
+    }
+    else if (action === 'search') {
+        searchSkills(skillsDir, name ?? '');
+    }
+    else if (action === 'show') {
+        if (!name) {
+            console.error(chalk.red('✗ Skill name required'));
+            process.exit(1);
+        }
+        showSkill(name, skillsDir);
+    }
+    else if (action === 'invoke') {
+        if (!name) {
+            console.error(chalk.red('✗ Skill name required'));
+            process.exit(1);
+        }
+        void invokeSkill(name, options?.input, skillsDir);
+    }
+    else if (action === 'add') {
+        if (!name) {
+            console.error(chalk.red('✗ Repository required (format: owner/repo)'));
+            process.exit(1);
+        }
+        void addSkill(name);
+    }
+    else {
+        console.error(chalk.red(`✗ Unknown action: ${action}`));
+        console.log(chalk.gray('Available actions: list, search, show, invoke, add'));
+        process.exit(1);
+    }
+}
+async function addSkill(ownerRepo) {
+    console.log(chalk.blue(`\nAdding skill from skills.sh: ${ownerRepo}`));
+    console.log('─'.repeat(60));
+    const result = await addSkillFromSkillssh(ownerRepo);
+    if (result.success) {
+        const skillName = result.skillName ?? 'unknown';
+        const skillDir = result.skillDir ?? 'unknown';
+        console.log(chalk.green(`✓ Skill added: ${skillName}`));
+        console.log(chalk.gray(`  Location: ${skillDir}`));
+    }
+    else {
+        const error = result.error ?? 'Unknown error';
+        console.error(chalk.red(`✗ ${error}`));
+        process.exit(1);
+    }
+}
+function listSkills(skillsDir) {
+    if (!existsSync(skillsDir)) {
+        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>'));
+        return;
+    }
+    const skills = readdirSync(skillsDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    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>'));
+        return;
+    }
+    console.log(chalk.bold('\nAvailable Skills:'));
+    console.log('─'.repeat(60));
+    for (const skillName of skills) {
+        const skillDir = getSkillDir(skillName);
+        const metadataPath = join(skillDir, 'metadata.yaml');
+        if (existsSync(metadataPath)) {
+            try {
+                const metadata = yaml.load(readFileSync(metadataPath, 'utf-8'));
+                const description = metadata.description ?? 'No description';
+                const sourceTag = metadata.source === 'skillssh' ? chalk.magenta(' [skills.sh]') : '';
+                const repoInfo = metadata.repo ? chalk.gray(` (${metadata.repo})`) : '';
+                console.log(`  ${chalk.cyan(skillName)}${sourceTag}${repoInfo}`);
+                console.log(`    ${chalk.gray(description)}`);
+            }
+            catch {
+                console.log(`  ${chalk.cyan(skillName)}`);
+            }
+        }
+        else {
+            console.log(`  ${chalk.cyan(skillName)}`);
+        }
+    }
+    console.log('─'.repeat(60));
+    console.log(chalk.gray(`Total: ${String(skills.length)} skill(s)`));
+}
+function searchSkills(skillsDir, query) {
+    if (!existsSync(skillsDir)) {
+        console.log(chalk.yellow('No skills found'));
+        return;
+    }
+    const skills = readdirSync(skillsDir, { withFileTypes: true })
+        .filter(dirent => dirent.isDirectory())
+        .map(dirent => dirent.name);
+    const results = skills.filter(skillName => {
+        const skillDir = getSkillDir(skillName);
+        const metadataPath = join(skillDir, 'metadata.yaml');
+        const skillPath = join(skillDir, 'skill.md');
+        if (existsSync(metadataPath)) {
+            try {
+                const metadata = yaml.load(readFileSync(metadataPath, 'utf-8'));
+                const text = `${skillName} ${metadata.description ?? ''} ${metadata.tags?.join(' ') ?? ''}`.toLowerCase();
+                return text.includes(query.toLowerCase());
+            }
+            catch {
+                return skillName.toLowerCase().includes(query.toLowerCase());
+            }
+        }
+        if (existsSync(skillPath)) {
+            const content = readFileSync(skillPath, 'utf-8').toLowerCase();
+            return content.includes(query.toLowerCase());
+        }
+        return skillName.toLowerCase().includes(query.toLowerCase());
+    });
+    if (results.length === 0) {
+        console.log(chalk.yellow(`No skills found matching: ${query}`));
+        return;
+    }
+    console.log(chalk.bold(`\nSearch Results for "${query}":`));
+    console.log('─'.repeat(60));
+    for (const skillName of results) {
+        console.log(`  ${chalk.cyan(skillName)}`);
+    }
+    console.log('─'.repeat(60));
+    console.log(chalk.gray(`Found: ${String(results.length)} skill(s)`));
+}
+function showSkill(skillName, _skillsDir) {
+    const skillDir = getSkillDir(skillName);
+    if (!existsSync(skillDir)) {
+        console.error(chalk.red(`✗ Skill not found: ${skillName}`));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`\nSkill: ${chalk.cyan(skillName)}`));
+    console.log('─'.repeat(60));
+    // Read skill.md
+    const skillPath = join(skillDir, 'skill.md');
+    if (existsSync(skillPath)) {
+        const content = readFileSync(skillPath, 'utf-8');
+        console.log(chalk.bold('\nDescription:'));
+        console.log(content);
+    }
+    // Read metadata.yaml
+    const metadataPath = join(skillDir, 'metadata.yaml');
+    if (existsSync(metadataPath)) {
+        try {
+            const metadata = yaml.load(readFileSync(metadataPath, 'utf-8'));
+            console.log(chalk.bold('\nMetadata:'));
+            console.log(`  Version: ${metadata.version ?? 'N/A'}`);
+            if (metadata.source === 'skillssh') {
+                console.log(`  Source: ${chalk.magenta('skills.sh')}`);
+                console.log(`  Repository: ${metadata.repo ?? 'N/A'}`);
+                if (metadata.importedAt) {
+                    console.log(`  Imported: ${metadata.importedAt}`);
+                }
+            }
+            if (metadata.tags && metadata.tags.length > 0) {
+                console.log(`  Tags: ${metadata.tags.join(', ')}`);
+            }
+            if (metadata.interface) {
+                console.log(chalk.bold('\nInterface:'));
+                if (metadata.interface.input && metadata.interface.input.length > 0) {
+                    console.log('  Input:');
+                    metadata.interface.input.forEach((input) => {
+                        console.log(`    - ${input.name} (${input.type})${input.required ? ' [required]' : ''}`);
+                    });
+                }
+                if (metadata.interface.output && Object.keys(metadata.interface.output).length > 0) {
+                    console.log('  Output:');
+                    Object.entries(metadata.interface.output).forEach(([key, value]) => {
+                        console.log(`    - ${key}: ${String(value)}`);
+                    });
+                }
+            }
+        }
+        catch {
+            console.log(chalk.yellow('  Could not parse metadata'));
+        }
+    }
+    console.log('─'.repeat(60));
+}
+async function invokeSkill(skillName, inputParams, _skillsDir) {
+    const skillDir = getSkillDir(skillName);
+    if (!existsSync(skillDir)) {
+        console.error(chalk.red(`✗ Skill not found: ${skillName}`));
+        process.exit(1);
+    }
+    console.log(chalk.bold(`\nInvoking skill: ${chalk.cyan(skillName)}`));
+    console.log('─'.repeat(60));
+    // Parse input parameters
+    const params = {};
+    if (inputParams) {
+        inputParams.split(',').forEach(param => {
+            const [key, value] = param.split('=').map(s => s.trim());
+            if (key && value) {
+                params[key] = value;
+            }
+        });
+    }
+    // Load skill metadata to validate inputs
+    const metadataPath = join(skillDir, 'metadata.yaml');
+    if (existsSync(metadataPath)) {
+        try {
+            const metadata = yaml.load(readFileSync(metadataPath, 'utf-8'));
+            if (metadata.interface?.input) {
+                console.log(chalk.bold('\nInput Parameters:'));
+                metadata.interface.input.forEach((input) => {
+                    const value = params[input.name] ?? (input.required ? chalk.red('MISSING') : 'not provided');
+                    const valueStr = typeof value === 'string' ? value : String(value);
+                    console.log(`  ${input.name}: ${valueStr}`);
+                });
+            }
+        }
+        catch {
+            // Ignore metadata parsing errors
+        }
+    }
+    // Execute skill in isolated context
+    console.log(chalk.bold('\nExecution Context:'));
+    console.log(chalk.gray('  Isolated execution context'));
+    console.log(chalk.gray('  Cross-agent invocation'));
+    // Import and use executeSkill function
+    const { executeSkill } = await import('../utils/skills.js');
+    try {
+        await executeSkill(skillName, `invoke-${String(Date.now())}`);
+        console.log(chalk.green('\n✓ Skill invocation completed'));
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        console.error(chalk.red(`\n✗ Skill invocation failed: ${errorMessage}`));
+        process.exit(1);
+    }
+}
+//# sourceMappingURL=skills.js.map

package/dist/types.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Shared type definitions for TMD CLI
+ */
+export interface PlanCommandOptions {
+    openspec?: boolean;
+    skill?: boolean;
+    useSkill?: string;
+    validateTasks?: boolean;
+}
+export interface DoCommandOptions {
+    data?: string;
+    skill?: string;
+    list?: boolean;
+    task?: number;
+    parallel?: boolean;
+    maxConcurrency?: number;
+}
+export interface CheckCommandOptions {
+    compare?: boolean;
+    validateSkill?: boolean;
+    analyze?: boolean;
+    recommend?: boolean;
+    manual?: boolean;
+}
+export interface ActCommandOptions {
+    standardize?: boolean;
+    complete?: boolean;
+    carryForward?: boolean;
+    manual?: boolean;
+}
+export interface ListCommandOptions {
+    status?: string;
+    phase?: string;
+}
+export interface SkillsCommandOptions {
+    input?: string;
+}
+export interface TaskMetadata {
+    status?: string;
+    lastUpdated?: string;
+    completed?: boolean;
+    completedAt?: string;
+    openspecChange?: string;
+    [key: string]: unknown;
+}
+export interface SkillMetadata {
+    name: string;
+    version?: string;
+    description?: string;
+    tags?: string[];
+    source?: 'skillssh' | 'local';
+    repo?: string;
+    importedAt?: string;
+    createdFrom?: string;
+    interface?: SkillInterface;
+}
+export interface SkillInterface {
+    input?: SkillInput[];
+    output?: Record<string, unknown>;
+}
+export interface SkillInput {
+    name: string;
+    type: string;
+    required?: boolean;
+    description?: string;
+}
+export interface SkillSteps {
+    steps?: SkillStep[];
+}
+export interface SkillStep {
+    type?: string;
+    description?: string;
+    operation?: string;
+    script?: string;
+    endpoint?: string;
+    depends?: string[] | number[];
+    [key: string]: unknown;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/types.js

@@ -0,0 +1,5 @@
+/**
+ * Shared type definitions for TMD CLI
+ */
+export {};
+//# sourceMappingURL=types.js.map

package/dist/utils/act-processing.d.ts

@@ -0,0 +1,64 @@
+export interface Success {
+    goal: string;
+    type: 'met' | 'over-achieved';
+    description: string;
+    practice?: string;
+}
+export interface Failure {
+    goal: string;
+    deviation: string;
+    severity: 'critical' | 'major' | 'minor';
+    rootCause?: string;
+    lesson?: string;
+}
+export interface UnresolvedIssue {
+    goal: string;
+    description: string;
+    priority: 'high' | 'medium' | 'low';
+    reason: string;
+    linkToDeviation?: string;
+}
+/**
+ * Parse evaluation results from evaluation.md
+ */
+export declare function parseEvaluationResults(evaluationPath: string): {
+    metGoals: string[];
+    unmetGoals: string[];
+    overAchievedGoals: string[];
+    partialGoals: string[];
+    summary?: {
+        totalGoals: number;
+        metGoals: number;
+        unmetGoals: number;
+        successRate: number;
+    };
+};
+/**
+ * Parse deviation analysis from deviation.md
+ */
+export declare function parseDeviationAnalysis(deviationPath: string): {
+    deviations: Array<{
+        description: string;
+        type: string;
+        severity: string;
+        status: string;
+    }>;
+    rootCauses: Array<{
+        category: string;
+        description: string;
+        evidence: string[];
+    }>;
+};
+/**
+ * Identify successes from evaluation results
+ */
+export declare function identifySuccesses(evaluationResults: ReturnType<typeof parseEvaluationResults>): Success[];
+/**
+ * Identify failures from deviations and root causes
+ */
+export declare function identifyFailures(deviationAnalysis: ReturnType<typeof parseDeviationAnalysis>, evaluationResults: ReturnType<typeof parseEvaluationResults>): Failure[];
+/**
+ * Identify unresolved issues for next cycle
+ */
+export declare function identifyUnresolvedIssues(evaluationResults: ReturnType<typeof parseEvaluationResults>, deviationAnalysis: ReturnType<typeof parseDeviationAnalysis>): UnresolvedIssue[];
+//# sourceMappingURL=act-processing.d.ts.map

package/dist/utils/act-processing.js

@@ -0,0 +1,222 @@
+import { readFileSync, existsSync } from 'fs';
+/**
+ * Parse evaluation results from evaluation.md
+ */
+export function parseEvaluationResults(evaluationPath) {
+    if (!existsSync(evaluationPath)) {
+        return {
+            metGoals: [],
+            unmetGoals: [],
+            overAchievedGoals: [],
+            partialGoals: []
+        };
+    }
+    const content = readFileSync(evaluationPath, 'utf-8');
+    const metGoals = [];
+    const unmetGoals = [];
+    const overAchievedGoals = [];
+    const partialGoals = [];
+    // Parse comparison table
+    const tableMatch = content.match(/## Comparison with Plan[\s\S]*?\|[-\s|]+\|([\s\S]*?)(?=\n##|$)/);
+    if (tableMatch?.[1]) {
+        const rows = tableMatch[1].trim().split('\n');
+        for (const row of rows) {
+            if (!row.trim() || !row.includes('|'))
+                continue;
+            const cells = row.split('|').map(c => c.trim()).filter(c => c);
+            if (cells.length >= 4 && cells[0] && cells[3]) {
+                const goal = cells[0];
+                const status = cells[3].toLowerCase();
+                if (status.includes('met') || status.includes('✅')) {
+                    metGoals.push(goal);
+                }
+                else if (status.includes('over') || status.includes('📈')) {
+                    overAchievedGoals.push(goal);
+                }
+                else if (status.includes('partial') || status.includes('⚠️')) {
+                    partialGoals.push(goal);
+                }
+                else if (status.includes('unmet') || status.includes('❌')) {
+                    unmetGoals.push(goal);
+                }
+            }
+        }
+    }
+    // Parse summary statistics
+    let summary;
+    const totalMatch = content.match(/Total goals:\s*(\d+)/i);
+    const metMatch = content.match(/Goals met:\s*(\d+)/i);
+    const unmetMatch = content.match(/Goals unmet:\s*(\d+)/i);
+    const rateMatch = content.match(/Success rate:\s*(\d+)%/i);
+    if (totalMatch?.[1] && metMatch?.[1]) {
+        summary = {
+            totalGoals: parseInt(totalMatch[1], 10),
+            metGoals: parseInt(metMatch[1], 10),
+            unmetGoals: unmetMatch?.[1] ? parseInt(unmetMatch[1], 10) : 0,
+            successRate: rateMatch?.[1] ? parseInt(rateMatch[1], 10) : 0
+        };
+    }
+    return {
+        metGoals,
+        unmetGoals,
+        overAchievedGoals,
+        partialGoals,
+        ...(summary ? { summary } : {})
+    };
+}
+/**
+ * Parse deviation analysis from deviation.md
+ */
+export function parseDeviationAnalysis(deviationPath) {
+    if (!existsSync(deviationPath)) {
+        return {
+            deviations: [],
+            rootCauses: []
+        };
+    }
+    const content = readFileSync(deviationPath, 'utf-8');
+    const deviations = [];
+    const rootCauses = [];
+    // Parse deviations
+    const deviationSection = content.match(/## Deviations Identified[\s\S]*?(?=\n##|$)/);
+    if (deviationSection?.[0]) {
+        const deviationBlocks = deviationSection[0].split(/### /).slice(1);
+        for (const block of deviationBlocks) {
+            const descMatch = block.match(/^([^\n]+)/);
+            const typeMatch = block.match(/\*\*Type\*\*:\s*([^\n]+)/);
+            const severityMatch = block.match(/\*\*Severity\*\*:\s*([^\n]+)/);
+            const statusMatch = block.match(/\*\*Status\*\*:\s*([^\n]+)/);
+            if (descMatch?.[1]) {
+                deviations.push({
+                    description: descMatch[1].trim(),
+                    type: typeMatch?.[1] ? typeMatch[1].trim() : 'unknown',
+                    severity: severityMatch?.[1] ? severityMatch[1].trim() : 'minor',
+                    status: statusMatch?.[1] ? statusMatch[1].trim() : 'unknown'
+                });
+            }
+        }
+    }
+    // Parse root causes
+    const rootCauseSection = content.match(/## Root Cause Analysis[\s\S]*?(?=\n##|$)/);
+    if (rootCauseSection?.[0]) {
+        const causeBlocks = rootCauseSection[0].split(/### /).slice(1);
+        for (const block of causeBlocks) {
+            const categoryMatch = block.match(/^([^\n]+)/);
+            const descMatch = block.match(/\n\n([^\n]+(?:\n[^\n]+)*?)(?=\n\*\*|$)/);
+            const evidenceMatch = block.match(/\*\*Evidence\*\*:([\s\S]*?)(?=\n\n|$)/);
+            if (categoryMatch?.[1]) {
+                const category = categoryMatch[1].trim();
+                const description = descMatch?.[1] ? descMatch[1].trim() : '';
+                const evidence = [];
+                if (evidenceMatch?.[1]) {
+                    const evidenceLines = evidenceMatch[1].split('\n').filter(l => l.trim().startsWith('-'));
+                    for (const line of evidenceLines) {
+                        const ev = line.replace(/^-\s*/, '').trim();
+                        if (ev)
+                            evidence.push(ev);
+                    }
+                }
+                rootCauses.push({
+                    category,
+                    description,
+                    evidence
+                });
+            }
+        }
+    }
+    return { deviations, rootCauses };
+}
+/**
+ * Identify successes from evaluation results
+ */
+export function identifySuccesses(evaluationResults) {
+    const successes = [];
+    // Met goals as successes
+    for (const goal of evaluationResults.metGoals) {
+        successes.push({
+            goal,
+            type: 'met',
+            description: `Successfully achieved goal: ${goal}`
+        });
+    }
+    // Over-achieved goals as successes
+    for (const goal of evaluationResults.overAchievedGoals) {
+        successes.push({
+            goal,
+            type: 'over-achieved',
+            description: `Exceeded expectations for goal: ${goal}`
+        });
+    }
+    return successes;
+}
+/**
+ * Identify failures from deviations and root causes
+ */
+export function identifyFailures(deviationAnalysis, evaluationResults) {
+    const failures = [];
+    // From unmet goals
+    for (const goal of evaluationResults.unmetGoals) {
+        failures.push({
+            goal,
+            deviation: `Goal not achieved: ${goal}`,
+            severity: 'major',
+            lesson: `Failed to achieve goal: ${goal}. Review execution approach and identify improvements.`
+        });
+    }
+    // From deviations
+    for (const deviation of deviationAnalysis.deviations) {
+        failures.push({
+            goal: deviation.description,
+            deviation: deviation.description,
+            severity: deviation.severity,
+            lesson: `Deviation identified: ${deviation.description}. Type: ${deviation.type}, Severity: ${deviation.severity}.`
+        });
+    }
+    // Link root causes to failures
+    for (const rootCause of deviationAnalysis.rootCauses) {
+        // Try to match root cause with failures
+        for (const failure of failures) {
+            if (failure.lesson?.toLowerCase().includes(rootCause.category.toLowerCase())) {
+                failure.rootCause = rootCause.description;
+            }
+        }
+    }
+    return failures;
+}
+/**
+ * Identify unresolved issues for next cycle
+ */
+export function identifyUnresolvedIssues(evaluationResults, deviationAnalysis) {
+    const issues = [];
+    // Unmet goals that need next cycle
+    for (const goal of evaluationResults.unmetGoals) {
+        issues.push({
+            goal,
+            description: `Address unmet goal: ${goal}`,
+            priority: 'high',
+            reason: 'Goal was not achieved in current cycle and requires attention in next cycle'
+        });
+    }
+    // Partial goals that need continuation
+    for (const goal of evaluationResults.partialGoals) {
+        issues.push({
+            goal,
+            description: `Continue work on partially achieved goal: ${goal}`,
+            priority: 'medium',
+            reason: 'Goal was partially achieved and needs continuation in next cycle'
+        });
+    }
+    // Critical deviations that need resolution
+    const criticalDeviations = deviationAnalysis.deviations.filter(d => d.severity === 'critical');
+    for (const deviation of criticalDeviations) {
+        issues.push({
+            goal: deviation.description,
+            description: `Resolve critical deviation: ${deviation.description}`,
+            priority: 'high',
+            reason: `Critical deviation identified: ${deviation.type}`,
+            linkToDeviation: deviation.description
+        });
+    }
+    return issues;
+}
+//# sourceMappingURL=act-processing.js.map

package/dist/utils/analysis.d.ts

@@ -0,0 +1,34 @@
+import type { ComparisonResult } from './comparison.js';
+export type DeviationType = 'timing' | 'scope' | 'quality' | 'resources';
+export type DeviationSeverity = 'critical' | 'major' | 'minor';
+export interface Deviation {
+    comparison: ComparisonResult;
+    type: DeviationType;
+    severity: DeviationSeverity;
+    description: string;
+}
+export interface RootCause {
+    category: 'planning' | 'execution' | 'external' | 'resources';
+    description: string;
+    evidence: string[];
+    confidence: 'high' | 'medium' | 'low';
+}
+export interface Recommendation {
+    priority: 'high' | 'medium' | 'low';
+    category: 'corrective' | 'preventive' | 'plan-modification';
+    action: string;
+    description: string;
+}
+/**
+ * Identify deviations from comparison results
+ */
+export declare function identifyDeviations(comparisons: ComparisonResult[]): Deviation[];
+/**
+ * Analyze root causes of deviations
+ */
+export declare function analyzeRootCauses(deviations: Deviation[]): RootCause[];
+/**
+ * Recommend adjustments based on analysis
+ */
+export declare function recommendAdjustments(deviations: Deviation[], rootCauses: RootCause[]): Recommendation[];
+//# sourceMappingURL=analysis.d.ts.map