@tmddev/tmd 0.1.0 → 0.3.0

package/dist/utils/skills.js

@@ -4,129 +4,113 @@ 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) {
+import { executeStep as executeStepWithExecutor } from './step-executor.js';
+/**
+ * Shared logic to write a skill directory. Used by createSkill (tmd plan --skill).
+ */
+function writeSkillDir(skillName, description, tags, createdFrom) {
     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]
+    const skillContent = `---
+name: ${skillName}
+description: ${description}
+---
 
-## Description
-${description}
+# ${description}
 
-## Prerequisites
-<!-- List prerequisites -->
+## Usage
 
-## Skill Steps
-<!-- Define executable steps -->
-1. 
-2. 
-3. 
+Define your skill steps in \`steps.yaml\` and configure parameters in \`config.yaml\`.
 
-## Expected Outcomes
-<!-- Define expected results -->
+## Steps
 
-## Validation Criteria
-<!-- Define how to validate success -->
+See \`steps.yaml\` for executable steps configuration.
 `;
-    writeFileSync(join(skillDir, 'skill.md'), skillContent);
-    // Create steps.yaml
+    writeFileSync(join(skillDir, 'SKILL.md'), skillContent);
     const stepsContent = {
-        steps: [
-            {
-                type: 'example',
-                description: 'Example step',
-                // Add step configuration
-            }
-        ]
+        steps: [{ type: 'example', description: 'Example step' }]
     };
     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
+    writeFileSync(join(skillDir, 'config.yaml'), yaml.dump({}));
     const metadataContent = {
         name: skillName,
         version: '1.0.0',
-        description: description,
-        tags: [],
-        createdFrom: taskId,
-        interface: {
-            input: [],
-            output: {}
-        }
+        description,
+        tags,
+        interface: { input: [], output: {} }
     };
+    if (createdFrom != null && createdFrom !== '') {
+        metadataContent['createdFrom'] = createdFrom;
+    }
     writeFileSync(join(skillDir, 'metadata.yaml'), yaml.dump(metadataContent));
+}
+/**
+ * Create a skill from a plan (tmd plan --skill). Generates name from description.
+ * Options.tags is applied when provided; options.taskId is used as createdFrom when provided.
+ */
+export function createSkill(description, taskId, options) {
+    const skillsDir = getSkillsDir();
+    ensureDir(skillsDir);
+    const skillName = generateTaskId(description).replace(/^\d+-/, '');
+    const skillDir = getSkillDir(skillName);
+    if (existsSync(skillDir)) {
+        console.log(chalk.yellow(`  Skill already exists: ${skillName}`));
+        return skillName;
+    }
+    const tags = options?.tags ?? [];
+    writeSkillDir(skillName, description, tags, taskId);
     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'}`));
+async function executeStep(step, stepIndex, taskId, workingDir) {
+    const startTime = Date.now();
+    try {
+        const context = {
+            taskId,
+            workingDir,
+            dryRun: false
+        };
+        const result = await executeStepWithExecutor(step, context);
+        if (result.success) {
+            console.log(chalk.green(`      ✓ Step ${String(stepIndex + 1)}: ${step.description ?? step.type}`));
+            if (result.output) {
+                console.log(chalk.gray(`        ${result.output}`));
             }
-            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
-            });
+        else {
+            console.log(chalk.red(`      ✗ Step ${String(stepIndex + 1)}: ${step.description ?? step.type}`));
+            if (result.error) {
+                console.log(chalk.red(`        ${result.error}`));
+            }
         }
-    });
+        return {
+            stepIndex,
+            success: result.success,
+            ...(result.error != null ? { error: result.error } : {}),
+            duration: result.duration
+        };
+    }
+    catch (error) {
+        const duration = Date.now() - startTime;
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.log(chalk.red(`      ✗ Step ${String(stepIndex + 1)}: ${errorMessage}`));
+        return {
+            stepIndex,
+            success: false,
+            error: errorMessage,
+            duration
+        };
+    }
 }
-async function executeStepsConcurrently(steps, maxConcurrency = Infinity) {
+async function executeStepsConcurrently(steps, maxConcurrency, taskId, workingDir) {
     const results = [];
     const executing = [];
     for (let i = 0; i < steps.length; i++) {
         const step = steps[i];
         if (!step)
             continue;
-        const stepDeps = step.depends ?? [];
+        const stepDeps = Array.isArray(step['depends']) ? step['depends'] : [];
         // Check if dependencies are satisfied (simplified - assumes sequential if dependencies exist)
         const hasDependencies = Array.isArray(stepDeps) && stepDeps.length > 0;
         if (hasDependencies) {
@@ -136,60 +120,60 @@ async function executeStepsConcurrently(steps, maxConcurrency = Infinity) {
             await Promise.all(executing);
             executing.length = 0;
         }
-        const promise = executeStep(step, i);
+        const promise = executeStep(step, i, taskId, workingDir);
         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;
+            // eslint-disable-next-line @typescript-eslint/no-floating-promises -- pool mutation; remaining promises are handled by Promise.allSettled below
+            executing.splice(executing.indexOf(promise), 1);
         }
     }
     // 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
-                });
-            }
+    const remainingResults = await Promise.allSettled(executing);
+    for (const result of remainingResults) {
+        if (result.status === 'fulfilled') {
+            results.push(result.value);
+        }
+        else {
+            results.push({
+                stepIndex: -1,
+                success: false,
+                error: result.reason instanceof Error ? result.reason.message : String(result.reason),
+                duration: 0
+            });
         }
     }
     return results.sort((a, b) => a.stepIndex - b.stepIndex);
 }
-export async function executeSkill(skillName, _taskId, parallel = false, maxConcurrency = Infinity) {
+function replaceVariables(obj, params) {
+    if (typeof obj === 'string') {
+        // Replace ${variable} with param value
+        const result = obj.replace(/\$\{(\w+)\}/g, (match, key) => {
+            return params[key] ?? match;
+        });
+        // Try to convert to number if the original was a number-like string
+        if (/^\d+$/.test(result)) {
+            const num = Number(result);
+            if (!isNaN(num)) {
+                return num;
+            }
+        }
+        return result;
+    }
+    else if (Array.isArray(obj)) {
+        return obj.map(item => replaceVariables(item, params));
+    }
+    else if (obj && typeof obj === 'object') {
+        const result = {};
+        for (const [key, value] of Object.entries(obj)) {
+            result[key] = replaceVariables(value, params);
+        }
+        return result;
+    }
+    return obj;
+}
+export async function executeSkill(skillName, taskId, parallel = false, maxConcurrency = Infinity, params = {}) {
     const skillDir = getSkillDir(skillName);
     if (!existsSync(skillDir)) {
         console.error(chalk.red(`✗ Skill not found: ${skillName}`));
@@ -201,17 +185,39 @@ export async function executeSkill(skillName, _taskId, parallel = false, maxConc
         return;
     }
     try {
+        // Load config.yaml for default values
+        const configPath = join(skillDir, 'config.yaml');
+        let configDefaults = {};
+        if (existsSync(configPath)) {
+            try {
+                const config = yaml.load(readFileSync(configPath, 'utf-8'));
+                configDefaults = config.defaults ?? {};
+            }
+            catch {
+                // Ignore config parsing errors
+            }
+        }
+        // Merge config defaults with provided params (params take precedence)
+        const mergedParams = { ...configDefaults, ...params };
+        // Convert all values to strings for variable replacement
+        const stringParams = {};
+        for (const [key, value] of Object.entries(mergedParams)) {
+            stringParams[key] = typeof value === 'string' ? value : String(value);
+        }
         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(`    Steps: ${String((steps.steps != null && Array.isArray(steps.steps) ? steps.steps : []).length)}`));
         console.log(chalk.gray(`    Mode: ${parallel ? 'concurrent' : 'sequential'}`));
-        if (steps.steps && Array.isArray(steps.steps)) {
+        const workingDir = skillDir;
+        // Replace variables in steps with merged parameters
+        const processedSteps = steps.steps != null ? replaceVariables(steps.steps, stringParams) : steps.steps;
+        if (processedSteps && Array.isArray(processedSteps)) {
             if (parallel) {
                 // Execute steps concurrently
-                const results = await executeStepsConcurrently(steps.steps, maxConcurrency);
+                const results = await executeStepsConcurrently(processedSteps, maxConcurrency, taskId, workingDir);
                 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`));
+                console.log(chalk.blue(`    Execution Summary: ${successCount.toString()} successful, ${failCount.toString()} failed`));
                 if (failCount > 0) {
                     const failedSteps = results.filter(r => !r.success);
                     throw new Error(`Skill execution failed: ${String(failedSteps.length)} step(s) failed`);
@@ -219,15 +225,12 @@ export async function executeSkill(skillName, _taskId, parallel = false, maxConc
             }
             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);
+                for (let i = 0; i < processedSteps.length; i++) {
+                    const step = processedSteps[i];
+                    console.log(chalk.gray(`    Step ${String(i + 1)}/${String(processedSteps.length)}: ${step.type}`));
+                    const result = await executeStep(step, i, taskId, workingDir);
                     if (!result.success) {
-                        const errorMsg = result.error ?? 'Unknown error';
-                        throw new Error(`Step ${String(i + 1)} failed: ${errorMsg}`);
+                        throw new Error(`Step ${String(i + 1)} failed: ${result.error ?? ''}`);
                     }
                 }
             }
@@ -235,8 +238,7 @@ export async function executeSkill(skillName, _taskId, parallel = false, maxConc
         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}`));
+        console.error(chalk.red(`✗ Error executing skill: ${String(e)}`));
         throw e;
     }
 }

package/dist/utils/skillssh.d.ts

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

package/dist/utils/skillssh.js

@@ -5,7 +5,7 @@ import yaml from 'js-yaml';
 /**
  * Fetches and converts a skill from skills.sh to TMD format
  */
-export async function addSkillFromSkillssh(ownerRepo) {
+export async function addSkillFromSkillssh(ownerRepo, skillName) {
     // Validate owner/repo format
     const parts = ownerRepo.split('/');
     if (parts.length !== 2 || !parts[0] || !parts[1]) {
@@ -15,21 +15,22 @@ export async function addSkillFromSkillssh(ownerRepo) {
         };
     }
     const [owner, repo] = parts;
-    const skillName = repo;
+    // Use provided skill name or derive from repo
+    const finalSkillName = skillName ?? repo;
     // Check if skill already exists
-    const skillDir = getSkillDir(skillName);
+    const skillDir = getSkillDir(finalSkillName);
     if (existsSync(skillDir)) {
         return {
             success: false,
-            error: `Skill already exists: ${skillName}`
+            error: `Skill already exists: ${finalSkillName}`
         };
     }
     // Fetch skill content from GitHub
-    const skillContent = await fetchSkillContent(owner, repo);
+    const skillContent = await fetchSkillContent(owner, repo, skillName);
     if (!skillContent.success) {
         return {
             success: false,
-            error: skillContent.error ?? 'Unknown error'
+            error: skillContent.error ?? 'Failed to fetch skill'
         };
     }
     // Create skill directory
@@ -39,21 +40,28 @@ export async function addSkillFromSkillssh(ownerRepo) {
     }
     mkdirSync(skillDir, { recursive: true });
     // Convert and save skill files
-    saveSkillFiles(skillDir, skillName, ownerRepo, skillContent.content ?? '');
+    saveSkillFiles(skillDir, finalSkillName, ownerRepo, skillContent.content ?? '', skillName);
     return {
         success: true,
-        skillName,
+        skillName: finalSkillName,
         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`,
-    ];
+async function fetchSkillContent(owner, repo, skillName) {
+    // Build possible paths
+    const possiblePaths = [];
+    if (skillName) {
+        // If skill name is provided, try subdirectory paths (skills.sh format)
+        const branches = ['main', 'master'];
+        for (const branch of branches) {
+            possiblePaths.push(`https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skills/${skillName}/SKILL.md`, `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skills/${skillName}/skill.md`, `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skills/${skillName}/README.md`);
+        }
+    }
+    // Also try root-level paths
+    const branches = ['main', 'master'];
+    for (const branch of branches) {
+        possiblePaths.push(`https://raw.githubusercontent.com/${owner}/${repo}/${branch}/SKILL.md`, `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skill.md`, `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/README.md`);
+    }
     for (const url of possiblePaths) {
         try {
             const response = await fetch(url);
@@ -66,30 +74,34 @@ async function fetchSkillContent(owner, repo) {
             // Continue to next URL
         }
     }
+    const skillHint = skillName ? ` (skill: ${skillName})` : '';
     return {
         success: false,
-        error: `Could not fetch skill from ${owner}/${repo}. Check that the repository exists and is public.`
+        error: `Could not fetch skill from ${owner}/${repo}${skillHint}. Check that the repository exists and is public.`
     };
 }
-function saveSkillFiles(skillDir, skillName, ownerRepo, content) {
+function saveSkillFiles(skillDir, skillName, ownerRepo, content, _originalSkillName) {
     // 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}\`
+    // Extract name and description from frontmatter or use defaults
+    const skillNameFromFrontmatter = typeof frontmatter['name'] === 'string' ? frontmatter['name'] : skillName;
+    const skillDescription = typeof frontmatter['description'] === 'string' ? frontmatter['description'] : `Skill imported from skills.sh: ${ownerRepo}`;
+    // Create SKILL.md (skills.sh format) with frontmatter
+    const skillMd = `---
+name: ${skillNameFromFrontmatter}
+description: ${skillDescription}
+---
 
-## Description
 ${body || 'No description available.'}
 `;
-    writeFileSync(join(skillDir, 'skill.md'), skillMd);
+    writeFileSync(join(skillDir, 'SKILL.md'), skillMd);
     // Create metadata.yaml with source attribution
+    // Use frontmatter values if available, otherwise use defaults
     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,
+        name: skillNameFromFrontmatter,
         version,
         description,
         tags,
@@ -112,7 +124,7 @@ ${body || 'No description available.'}
         steps: [
             {
                 type: 'procedural',
-                description: 'This skill contains procedural knowledge. See skill.md for details.'
+                description: 'This skill contains procedural knowledge. See SKILL.md for details.'
             }
         ]
     };

package/dist/utils/step-executor.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Step executors for automated task and skill execution
+ */
+export interface StepResult {
+    success: boolean;
+    output?: string;
+    error?: string;
+    exitCode?: number;
+    duration: number;
+    data?: Record<string, unknown>;
+}
+export interface ExecutionContext {
+    taskId: string;
+    workingDir: string;
+    env?: Record<string, string>;
+    dryRun?: boolean;
+}
+export interface Step {
+    type: string;
+    description?: string;
+    [key: string]: unknown;
+}
+export interface StepExecutor {
+    type: string;
+    execute(step: Step, context: ExecutionContext): Promise<StepResult>;
+}
+/**
+ * Bash step executor - executes shell commands
+ */
+export declare class BashStepExecutor implements StepExecutor {
+    type: string;
+    execute(step: Step, context: ExecutionContext): Promise<StepResult>;
+}
+/**
+ * File step executor - performs file operations
+ */
+export declare class FileStepExecutor implements StepExecutor {
+    type: string;
+    execute(step: Step, context: ExecutionContext): Promise<StepResult>;
+}
+/**
+ * API step executor - makes HTTP requests
+ */
+export declare class ApiStepExecutor implements StepExecutor {
+    type: string;
+    execute(step: Step, context: ExecutionContext): Promise<StepResult>;
+}
+/**
+ * Script step executor - executes Node.js scripts
+ */
+export declare class ScriptStepExecutor implements StepExecutor {
+    type: string;
+    execute(step: Step, context: ExecutionContext): Promise<StepResult>;
+}
+export declare function getStepExecutor(type: string): Promise<StepExecutor | undefined>;
+export declare function registerStepExecutor(executor: StepExecutor): void;
+export declare function executeStep(step: Step, context: ExecutionContext): Promise<StepResult>;
+//# sourceMappingURL=step-executor.d.ts.map