@tmddev/tmd 0.1.0

package/dist/utils/skills.js

@@ -0,0 +1,248 @@
+import { existsSync, mkdirSync, writeFileSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { getSkillsDir, getSkillDir } from './paths.js';
+import { generateTaskId } from './task-id.js';
+import yaml from 'js-yaml';
+import chalk from 'chalk';
+export function createSkill(description, taskId) {
+    const skillsDir = getSkillsDir();
+    ensureDir(skillsDir);
+    // Generate skill name from description
+    const skillName = generateTaskId(description).replace(/^\d+-/, '');
+    const skillDir = getSkillDir(skillName);
+    if (existsSync(skillDir)) {
+        console.log(chalk.yellow(`  Skill already exists: ${skillName}`));
+        return skillName;
+    }
+    mkdirSync(skillDir, { recursive: true });
+    // Create skill.md with user story template
+    const skillContent = `# Skill: ${description}
+
+## User Story
+As a [role], I want to [action], so as to [benefit]
+
+## Description
+${description}
+
+## Prerequisites
+<!-- List prerequisites -->
+
+## Skill Steps
+<!-- Define executable steps -->
+1. 
+2. 
+3. 
+
+## Expected Outcomes
+<!-- Define expected results -->
+
+## Validation Criteria
+<!-- Define how to validate success -->
+`;
+    writeFileSync(join(skillDir, 'skill.md'), skillContent);
+    // Create steps.yaml
+    const stepsContent = {
+        steps: [
+            {
+                type: 'example',
+                description: 'Example step',
+                // Add step configuration
+            }
+        ]
+    };
+    writeFileSync(join(skillDir, 'steps.yaml'), yaml.dump(stepsContent));
+    // Create config.yaml
+    const configContent = {
+    // Configuration for skill execution
+    };
+    writeFileSync(join(skillDir, 'config.yaml'), yaml.dump(configContent));
+    // Create metadata.yaml
+    const metadataContent = {
+        name: skillName,
+        version: '1.0.0',
+        description: description,
+        tags: [],
+        createdFrom: taskId,
+        interface: {
+            input: [],
+            output: {}
+        }
+    };
+    writeFileSync(join(skillDir, 'metadata.yaml'), yaml.dump(metadataContent));
+    return skillName;
+}
+function executeStep(step, stepIndex) {
+    return new Promise((resolve) => {
+        const startTime = Date.now();
+        try {
+            // Basic step execution based on type
+            switch (step.type) {
+                case 'database':
+                    console.log(chalk.yellow(`      Database operation: ${step.operation ?? 'query'}`));
+                    // TODO: Implement database operations
+                    break;
+                case 'file':
+                    console.log(chalk.yellow(`      File operation: ${step.operation ?? 'read'}`));
+                    // TODO: Implement file operations
+                    break;
+                case 'script':
+                    console.log(chalk.yellow(`      Script execution: ${step.script ?? 'unknown'}`));
+                    // TODO: Implement script execution
+                    break;
+                case 'api':
+                    console.log(chalk.yellow(`      API call: ${step.endpoint ?? 'unknown'}`));
+                    // TODO: Implement API calls
+                    break;
+                case 'image':
+                    console.log(chalk.yellow(`      Image processing: ${step.operation ?? 'process'}`));
+                    // TODO: Implement image processing
+                    break;
+                default:
+                    console.log(chalk.yellow(`      Unknown step type: ${step.type ?? 'undefined'}`));
+            }
+            const duration = Date.now() - startTime;
+            resolve({
+                stepIndex,
+                success: true,
+                duration
+            });
+        }
+        catch (error) {
+            const duration = Date.now() - startTime;
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            resolve({
+                stepIndex,
+                success: false,
+                error: errorMessage,
+                duration
+            });
+        }
+    });
+}
+async function executeStepsConcurrently(steps, maxConcurrency = Infinity) {
+    const results = [];
+    const executing = [];
+    for (let i = 0; i < steps.length; i++) {
+        const step = steps[i];
+        if (!step)
+            continue;
+        const stepDeps = step.depends ?? [];
+        // Check if dependencies are satisfied (simplified - assumes sequential if dependencies exist)
+        const hasDependencies = Array.isArray(stepDeps) && stepDeps.length > 0;
+        if (hasDependencies) {
+            // Wait for dependencies to complete before executing
+            // For now, execute sequentially if dependencies exist
+            // TODO: Implement proper dependency resolution
+            await Promise.all(executing);
+            executing.length = 0;
+        }
+        const promise = executeStep(step, i);
+        executing.push(promise);
+        if (executing.length >= maxConcurrency) {
+            const completed = await Promise.race(executing);
+            results.push(completed);
+            // Remove one promise from executing (the one that completed)
+            // We can't reliably identify which one, so remove the first
+            // The promise is already resolved by Promise.race, so we can safely remove it
+            const removedPromise = executing.shift();
+            // Explicitly mark as handled to satisfy ESLint
+            void removedPromise;
+        }
+    }
+    // Wait for remaining steps
+    if (executing.length > 0) {
+        const remainingResults = await Promise.allSettled(executing);
+        for (const result of remainingResults) {
+            if (result.status === 'fulfilled') {
+                results.push(result.value);
+            }
+            else {
+                // Handle rejected promise - reason can be any type
+                const reason = result.reason;
+                let errorMessage;
+                if (reason instanceof Error) {
+                    errorMessage = reason.message;
+                }
+                else if (typeof reason === 'string') {
+                    errorMessage = reason;
+                }
+                else if (reason === null || reason === undefined) {
+                    errorMessage = 'Unknown error';
+                }
+                else {
+                    // For other types, use JSON.stringify if possible, otherwise fallback
+                    try {
+                        errorMessage = JSON.stringify(reason);
+                    }
+                    catch {
+                        errorMessage = 'Unknown error';
+                    }
+                }
+                results.push({
+                    stepIndex: -1,
+                    success: false,
+                    error: errorMessage,
+                    duration: 0
+                });
+            }
+        }
+    }
+    return results.sort((a, b) => a.stepIndex - b.stepIndex);
+}
+export async function executeSkill(skillName, _taskId, parallel = false, maxConcurrency = Infinity) {
+    const skillDir = getSkillDir(skillName);
+    if (!existsSync(skillDir)) {
+        console.error(chalk.red(`✗ Skill not found: ${skillName}`));
+        return;
+    }
+    const stepsPath = join(skillDir, 'steps.yaml');
+    if (!existsSync(stepsPath)) {
+        console.error(chalk.red(`✗ Skill steps not found: ${skillName}`));
+        return;
+    }
+    try {
+        const steps = yaml.load(readFileSync(stepsPath, 'utf-8'));
+        console.log(chalk.blue(`  Executing skill: ${skillName}`));
+        console.log(chalk.gray(`    Steps: ${String(steps.steps?.length ?? 0)}`));
+        console.log(chalk.gray(`    Mode: ${parallel ? 'concurrent' : 'sequential'}`));
+        if (steps.steps && Array.isArray(steps.steps)) {
+            if (parallel) {
+                // Execute steps concurrently
+                const results = await executeStepsConcurrently(steps.steps, maxConcurrency);
+                const successCount = results.filter(r => r.success).length;
+                const failCount = results.length - successCount;
+                console.log(chalk.blue(`    Execution Summary: ${String(successCount)} successful, ${String(failCount)} failed`));
+                if (failCount > 0) {
+                    const failedSteps = results.filter(r => !r.success);
+                    throw new Error(`Skill execution failed: ${String(failedSteps.length)} step(s) failed`);
+                }
+            }
+            else {
+                // Execute steps sequentially (original behavior)
+                for (let i = 0; i < steps.steps.length; i++) {
+                    const step = steps.steps[i];
+                    if (!step)
+                        continue;
+                    console.log(chalk.gray(`    Step ${String(i + 1)}/${String(steps.steps.length)}: ${step.type ?? 'unknown'}`));
+                    const result = await executeStep(step, i);
+                    if (!result.success) {
+                        const errorMsg = result.error ?? 'Unknown error';
+                        throw new Error(`Step ${String(i + 1)} failed: ${errorMsg}`);
+                    }
+                }
+            }
+        }
+        console.log(chalk.green(`  ✓ Skill execution completed: ${skillName}`));
+    }
+    catch (e) {
+        const errorMessage = e instanceof Error ? e.message : String(e);
+        console.error(chalk.red(`✗ Error executing skill: ${errorMessage}`));
+        throw e;
+    }
+}
+function ensureDir(path) {
+    if (!existsSync(path)) {
+        mkdirSync(path, { recursive: true });
+    }
+}
+//# sourceMappingURL=skills.js.map

package/dist/utils/skillssh.d.ts

@@ -0,0 +1,12 @@
+interface SkillsshResult {
+    success: boolean;
+    skillName?: string;
+    skillDir?: string;
+    error?: string;
+}
+/**
+ * Fetches and converts a skill from skills.sh to TMD format
+ */
+export declare function addSkillFromSkillssh(ownerRepo: string): Promise<SkillsshResult>;
+export {};
+//# sourceMappingURL=skillssh.d.ts.map

package/dist/utils/skillssh.js

@@ -0,0 +1,135 @@
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { getSkillsDir, getSkillDir } from './paths.js';
+import yaml from 'js-yaml';
+/**
+ * Fetches and converts a skill from skills.sh to TMD format
+ */
+export async function addSkillFromSkillssh(ownerRepo) {
+    // Validate owner/repo format
+    const parts = ownerRepo.split('/');
+    if (parts.length !== 2 || !parts[0] || !parts[1]) {
+        return {
+            success: false,
+            error: `Invalid format: "${ownerRepo}". Expected: <owner>/<repo>`
+        };
+    }
+    const [owner, repo] = parts;
+    const skillName = repo;
+    // Check if skill already exists
+    const skillDir = getSkillDir(skillName);
+    if (existsSync(skillDir)) {
+        return {
+            success: false,
+            error: `Skill already exists: ${skillName}`
+        };
+    }
+    // Fetch skill content from GitHub
+    const skillContent = await fetchSkillContent(owner, repo);
+    if (!skillContent.success) {
+        return {
+            success: false,
+            error: skillContent.error ?? 'Unknown error'
+        };
+    }
+    // Create skill directory
+    const skillsDir = getSkillsDir();
+    if (!existsSync(skillsDir)) {
+        mkdirSync(skillsDir, { recursive: true });
+    }
+    mkdirSync(skillDir, { recursive: true });
+    // Convert and save skill files
+    saveSkillFiles(skillDir, skillName, ownerRepo, skillContent.content ?? '');
+    return {
+        success: true,
+        skillName,
+        skillDir
+    };
+}
+async function fetchSkillContent(owner, repo) {
+    // Try common skill file locations
+    const possiblePaths = [
+        `https://raw.githubusercontent.com/${owner}/${repo}/main/README.md`,
+        `https://raw.githubusercontent.com/${owner}/${repo}/master/README.md`,
+        `https://raw.githubusercontent.com/${owner}/${repo}/main/skill.md`,
+        `https://raw.githubusercontent.com/${owner}/${repo}/master/skill.md`,
+    ];
+    for (const url of possiblePaths) {
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                const content = await response.text();
+                return { success: true, content };
+            }
+        }
+        catch {
+            // Continue to next URL
+        }
+    }
+    return {
+        success: false,
+        error: `Could not fetch skill from ${owner}/${repo}. Check that the repository exists and is public.`
+    };
+}
+function saveSkillFiles(skillDir, skillName, ownerRepo, content) {
+    // Parse frontmatter if present
+    const { frontmatter, body } = parseFrontmatter(content);
+    // Create skill.md
+    const skillMd = `# Skill: ${skillName}
+
+## Source
+Imported from [skills.sh](https://skills.sh): \`${ownerRepo}\`
+
+## Description
+${body || 'No description available.'}
+`;
+    writeFileSync(join(skillDir, 'skill.md'), skillMd);
+    // Create metadata.yaml with source attribution
+    const version = typeof frontmatter['version'] === 'string' ? frontmatter['version'] : '1.0.0';
+    const description = typeof frontmatter['description'] === 'string' ? frontmatter['description'] : `Skill imported from skills.sh: ${ownerRepo}`;
+    const tags = Array.isArray(frontmatter['tags']) ? frontmatter['tags'] : [];
+    const metadata = {
+        name: skillName,
+        version,
+        description,
+        tags,
+        source: 'skillssh',
+        repo: ownerRepo,
+        importedAt: new Date().toISOString(),
+        interface: {
+            input: [],
+            output: {}
+        }
+    };
+    writeFileSync(join(skillDir, 'metadata.yaml'), yaml.dump(metadata));
+    // Create config.yaml
+    const config = {
+    // Default configuration
+    };
+    writeFileSync(join(skillDir, 'config.yaml'), yaml.dump(config));
+    // Create steps.yaml placeholder
+    const steps = {
+        steps: [
+            {
+                type: 'procedural',
+                description: 'This skill contains procedural knowledge. See skill.md for details.'
+            }
+        ]
+    };
+    writeFileSync(join(skillDir, 'steps.yaml'), yaml.dump(steps));
+}
+function parseFrontmatter(content) {
+    const frontmatterRegex = /^---\n([\s\S]*?)\n---\n([\s\S]*)$/;
+    const match = content.match(frontmatterRegex);
+    if (match?.[1] && match[2]) {
+        try {
+            const frontmatter = yaml.load(match[1]);
+            return { frontmatter: frontmatter ?? {}, body: match[2].trim() };
+        }
+        catch {
+            return { frontmatter: {}, body: content };
+        }
+    }
+    return { frontmatter: {}, body: content };
+}
+//# sourceMappingURL=skillssh.js.map

package/dist/utils/standardization.d.ts

@@ -0,0 +1,26 @@
+import type { Success } from './act-processing.js';
+export interface SuccessfulPractice {
+    description: string;
+    context: string;
+    category: 'process' | 'tool' | 'approach' | 'pattern';
+    applicability: string;
+    steps: string[];
+}
+export interface StandardizationRecommendation {
+    practice: SuccessfulPractice;
+    recommendation: string;
+    priority: 'high' | 'medium' | 'low';
+}
+/**
+ * Extract successful practices from successes
+ */
+export declare function extractSuccessfulPractices(successes: Success[]): SuccessfulPractice[];
+/**
+ * Generate standardization recommendations
+ */
+export declare function generateStandardizationRecommendations(practices: SuccessfulPractice[]): StandardizationRecommendation[];
+/**
+ * Format standardization document content
+ */
+export declare function formatStandardizationDocument(practices: SuccessfulPractice[], recommendations: StandardizationRecommendation[]): string;
+//# sourceMappingURL=standardization.d.ts.map

package/dist/utils/standardization.js

@@ -0,0 +1,106 @@
+/**
+ * Extract successful practices from successes
+ */
+export function extractSuccessfulPractices(successes) {
+    const practices = [];
+    for (const success of successes) {
+        // Determine category based on goal description
+        const goalLower = success.goal.toLowerCase();
+        let category = 'process';
+        if (goalLower.includes('tool') || goalLower.includes('system') || goalLower.includes('platform')) {
+            category = 'tool';
+        }
+        else if (goalLower.includes('approach') || goalLower.includes('method') || goalLower.includes('strategy')) {
+            category = 'approach';
+        }
+        else if (goalLower.includes('pattern') || goalLower.includes('template') || goalLower.includes('standard')) {
+            category = 'pattern';
+        }
+        practices.push({
+            description: success.goal,
+            context: `Successfully achieved in current PDCA cycle`,
+            category,
+            applicability: `Applicable when similar goals or contexts are encountered`,
+            steps: [
+                `Review the approach used to achieve: ${success.goal}`,
+                `Document the key factors that contributed to success`,
+                `Identify conditions where this practice can be applied`,
+                `Create reusable template or checklist if applicable`
+            ]
+        });
+    }
+    return practices;
+}
+/**
+ * Generate standardization recommendations
+ */
+export function generateStandardizationRecommendations(practices) {
+    const recommendations = [];
+    for (const practice of practices) {
+        let priority = 'medium';
+        // Higher priority for over-achieved goals
+        if (practice.description.toLowerCase().includes('exceed') ||
+            practice.description.toLowerCase().includes('over-achieved')) {
+            priority = 'high';
+        }
+        // Higher priority for process and pattern practices
+        if (practice.category === 'process' || practice.category === 'pattern') {
+            priority = 'high';
+        }
+        recommendations.push({
+            practice,
+            recommendation: `Standardize the practice: ${practice.description}. This practice was successful and can be reused in similar contexts.`,
+            priority
+        });
+    }
+    return recommendations;
+}
+/**
+ * Format standardization document content
+ */
+export function formatStandardizationDocument(practices, recommendations) {
+    let content = '# Standardization: Successful Practices\n\n';
+    content += 'This document identifies successful practices from the current PDCA cycle that should be standardized for future use.\n\n';
+    if (practices.length === 0) {
+        content += 'No successful practices identified for standardization.\n';
+        return content;
+    }
+    content += '## Successful Practices Identified\n\n';
+    content += `Total practices: ${String(practices.length)}\n\n`;
+    // Group by category
+    const byCategory = {};
+    for (const practice of practices) {
+        const category = practice.category;
+        byCategory[category] ??= [];
+        byCategory[category].push(practice);
+    }
+    for (const [category, categoryPractices] of Object.entries(byCategory)) {
+        content += `### ${category.charAt(0).toUpperCase() + category.slice(1)} Practices\n\n`;
+        for (const practice of categoryPractices) {
+            content += `#### ${practice.description}\n\n`;
+            content += `**Context**: ${practice.context}\n\n`;
+            content += `**Applicability**: ${practice.applicability}\n\n`;
+            content += `**Steps to Implement**:\n`;
+            for (const step of practice.steps) {
+                content += `- ${step}\n`;
+            }
+            content += '\n';
+        }
+    }
+    content += '## Standardization Recommendations\n\n';
+    for (const rec of recommendations) {
+        const priorityEmoji = rec.priority === 'high' ? '🔴' : rec.priority === 'medium' ? '🟡' : '🟢';
+        content += `### ${priorityEmoji} ${rec.priority.toUpperCase()} Priority: ${rec.practice.description}\n\n`;
+        content += `${rec.recommendation}\n\n`;
+    }
+    const patternPractices = practices.filter(p => p.category === 'pattern');
+    if (patternPractices.length > 0) {
+        content += '## Reusable Patterns\n\n';
+        content += 'The following patterns can be reused in future PDCA cycles:\n\n';
+        for (const practice of patternPractices) {
+            content += `- **${practice.description}**: ${practice.applicability}\n`;
+        }
+    }
+    return content;
+}
+//# sourceMappingURL=standardization.js.map

package/dist/utils/task-chain.d.ts

@@ -0,0 +1,35 @@
+import type { Task } from './tasks.js';
+export interface TaskExecutionResult {
+    taskIndex: number;
+    success: boolean;
+    error?: string;
+    duration: number;
+}
+export interface TaskChain {
+    tasks: Task[];
+    dependencyGraph: Map<number, number[]>;
+    executionOrder: number[][];
+}
+/**
+ * Build dependency graph from tasks
+ * Returns a map of task index to array of dependency indices
+ */
+export declare function buildDependencyGraph(tasks: Task[]): Map<number, number[]>;
+/**
+ * Detect cycles in dependency graph using DFS
+ */
+export declare function detectCycles(graph: Map<number, number[]>): number[] | null;
+/**
+ * Topological sort to determine execution order
+ * Returns array of arrays, where each inner array contains tasks that can run concurrently
+ */
+export declare function topologicalSort(tasks: Task[], graph: Map<number, number[]>): number[][];
+/**
+ * Execute tasks concurrently with dependency management
+ * @param tasks Array of tasks to execute
+ * @param executeTask Function to execute a single task
+ * @param maxConcurrency Maximum number of concurrent executions
+ * @returns Array of execution results
+ */
+export declare function executeConcurrently(tasks: Task[], executeTask: (task: Task) => Promise<TaskExecutionResult>, maxConcurrency?: number): Promise<TaskExecutionResult[]>;
+//# sourceMappingURL=task-chain.d.ts.map