@tmddev/tmd 0.1.0 → 0.2.0

package/dist/utils/step-executor.js

@@ -0,0 +1,374 @@
+/**
+ * Step executors for automated task and skill execution
+ */
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { existsSync, readFileSync, writeFileSync, copyFileSync, unlinkSync } from 'fs';
+import { resolve } from 'path';
+import { pathToFileURL } from 'url';
+const execAsync = promisify(exec);
+/**
+ * Bash step executor - executes shell commands
+ */
+export class BashStepExecutor {
+    type = 'bash';
+    async execute(step, context) {
+        const startTime = Date.now();
+        const command = step['command'];
+        const ignoreErrors = step['ignoreErrors'] ?? false;
+        const timeout = step['timeout'] ?? 60000; // Default 60s timeout
+        if (!command) {
+            return {
+                success: false,
+                error: 'No command specified for bash step',
+                duration: Date.now() - startTime
+            };
+        }
+        if (context.dryRun) {
+            return {
+                success: true,
+                output: `[DRY RUN] Would execute: ${command}`,
+                duration: Date.now() - startTime
+            };
+        }
+        try {
+            const { stdout, stderr } = await execAsync(command, {
+                cwd: context.workingDir,
+                env: { ...process.env, ...context.env },
+                timeout
+            });
+            return {
+                success: true,
+                output: stdout,
+                ...(stderr ? { error: stderr } : {}),
+                exitCode: 0,
+                duration: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            const execError = error;
+            const duration = Date.now() - startTime;
+            const errMsg = execError.stderr ?? execError.message;
+            if (ignoreErrors) {
+                return {
+                    success: true,
+                    output: execError.stdout ?? '',
+                    ...(errMsg != null ? { error: errMsg } : {}),
+                    exitCode: execError.code ?? 1,
+                    duration
+                };
+            }
+            return {
+                success: false,
+                output: execError.stdout ?? '',
+                error: errMsg ?? String(error),
+                exitCode: execError.code ?? 1,
+                duration
+            };
+        }
+    }
+}
+/**
+ * File step executor - performs file operations
+ */
+export class FileStepExecutor {
+    type = 'file';
+    async execute(step, context) {
+        await Promise.resolve(); // satisfy require-await; all ops are sync
+        const startTime = Date.now();
+        const operation = step['operation'];
+        const path = step['path'];
+        const content = step['content'];
+        const destination = step['destination'];
+        if (!operation) {
+            return {
+                success: false,
+                error: 'No operation specified for file step',
+                duration: Date.now() - startTime
+            };
+        }
+        if (!path) {
+            return {
+                success: false,
+                error: 'No path specified for file step',
+                duration: Date.now() - startTime
+            };
+        }
+        if (context.dryRun) {
+            return {
+                success: true,
+                output: `[DRY RUN] Would perform file ${operation} on: ${path}`,
+                duration: Date.now() - startTime
+            };
+        }
+        try {
+            switch (operation) {
+                case 'read': {
+                    if (!existsSync(path)) {
+                        return {
+                            success: false,
+                            error: `File not found: ${path}`,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    const fileContent = readFileSync(path, 'utf-8');
+                    return {
+                        success: true,
+                        output: fileContent,
+                        data: { content: fileContent, path },
+                        duration: Date.now() - startTime
+                    };
+                }
+                case 'write': {
+                    if (content === undefined) {
+                        return {
+                            success: false,
+                            error: 'No content specified for write operation',
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    writeFileSync(path, content);
+                    return {
+                        success: true,
+                        output: `Written ${String(content.length)} bytes to ${path}`,
+                        data: { path, bytesWritten: content.length },
+                        duration: Date.now() - startTime
+                    };
+                }
+                case 'copy': {
+                    if (!destination) {
+                        return {
+                            success: false,
+                            error: 'No destination specified for copy operation',
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    if (!existsSync(path)) {
+                        return {
+                            success: false,
+                            error: `Source file not found: ${path}`,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    copyFileSync(path, destination);
+                    return {
+                        success: true,
+                        output: `Copied ${path} to ${destination}`,
+                        data: { source: path, destination },
+                        duration: Date.now() - startTime
+                    };
+                }
+                case 'delete': {
+                    if (!existsSync(path)) {
+                        return {
+                            success: true,
+                            output: `File does not exist: ${path}`,
+                            duration: Date.now() - startTime
+                        };
+                    }
+                    unlinkSync(path);
+                    return {
+                        success: true,
+                        output: `Deleted ${path}`,
+                        data: { path },
+                        duration: Date.now() - startTime
+                    };
+                }
+                case 'exists': {
+                    const exists = existsSync(path);
+                    return {
+                        success: true,
+                        output: exists ? `File exists: ${path}` : `File does not exist: ${path}`,
+                        data: { path, exists },
+                        duration: Date.now() - startTime
+                    };
+                }
+                default:
+                    return {
+                        success: false,
+                        error: `Unknown file operation: ${operation}`,
+                        duration: Date.now() - startTime
+                    };
+            }
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - startTime
+            };
+        }
+    }
+}
+/**
+ * API step executor - makes HTTP requests
+ */
+export class ApiStepExecutor {
+    type = 'api';
+    async execute(step, context) {
+        const startTime = Date.now();
+        const url = step['url'];
+        const method = (step['method'] ?? 'GET').toUpperCase();
+        const headers = step['headers'];
+        const body = step['body'];
+        const timeout = step['timeout'] ?? 30000;
+        if (!url) {
+            return {
+                success: false,
+                error: 'No URL specified for API step',
+                duration: Date.now() - startTime
+            };
+        }
+        if (context.dryRun) {
+            return {
+                success: true,
+                output: `[DRY RUN] Would make ${method} request to: ${url}`,
+                duration: Date.now() - startTime
+            };
+        }
+        try {
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => { controller.abort(); }, timeout);
+            const requestBody = body
+                ? typeof body === 'string' ? body : JSON.stringify(body)
+                : undefined;
+            const response = await fetch(url, {
+                method,
+                headers: {
+                    'Content-Type': 'application/json',
+                    ...headers
+                },
+                ...(requestBody !== undefined ? { body: requestBody } : {}),
+                signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            const responseText = await response.text();
+            let responseData;
+            try {
+                responseData = JSON.parse(responseText);
+            }
+            catch {
+                responseData = responseText;
+            }
+            if (!response.ok) {
+                return {
+                    success: false,
+                    output: responseText,
+                    error: `HTTP ${String(response.status)}: ${response.statusText}`,
+                    data: { status: response.status, response: responseData },
+                    duration: Date.now() - startTime
+                };
+            }
+            return {
+                success: true,
+                output: responseText,
+                data: { status: response.status, response: responseData },
+                duration: Date.now() - startTime
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - startTime
+            };
+        }
+    }
+}
+/**
+ * Script step executor - executes Node.js scripts
+ */
+export class ScriptStepExecutor {
+    type = 'script';
+    async execute(step, context) {
+        const startTime = Date.now();
+        const scriptPath = step['script'];
+        const args = step['args'];
+        const timeout = step['timeout'] ?? 60000;
+        if (!scriptPath) {
+            return {
+                success: false,
+                error: 'No script path specified for script step',
+                duration: Date.now() - startTime
+            };
+        }
+        if (context.dryRun) {
+            return {
+                success: true,
+                output: `[DRY RUN] Would execute script: ${scriptPath}`,
+                duration: Date.now() - startTime
+            };
+        }
+        try {
+            // Resolve script path relative to working directory
+            const fullScriptPath = resolve(context.workingDir, scriptPath);
+            if (!existsSync(fullScriptPath)) {
+                return {
+                    success: false,
+                    error: `Script not found: ${fullScriptPath}`,
+                    duration: Date.now() - startTime
+                };
+            }
+            const scriptModule = await import(pathToFileURL(fullScriptPath).href);
+            const scriptFn = scriptModule.default ?? scriptModule.main ?? scriptModule.execute;
+            if (typeof scriptFn !== 'function') {
+                return {
+                    success: false,
+                    error: `Script does not export a default function, main, or execute function`,
+                    duration: Date.now() - startTime
+                };
+            }
+            // Execute script with timeout
+            const controller = new AbortController();
+            const timeoutId = setTimeout(() => { controller.abort(); }, timeout);
+            const result = await Promise.race([
+                scriptFn(args ?? {}, context),
+                new Promise((_, reject) => {
+                    controller.signal.addEventListener('abort', () => {
+                        reject(new Error(`Script execution timeout after ${String(timeout)}ms`));
+                    });
+                })
+            ]);
+            clearTimeout(timeoutId);
+            return {
+                success: result.success,
+                duration: Date.now() - startTime,
+                ...(result.output !== undefined && { output: result.output }),
+                ...(result.error !== undefined && { error: result.error }),
+                ...(result.data !== undefined && { data: result.data })
+            };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error instanceof Error ? error.message : String(error),
+                duration: Date.now() - startTime
+            };
+        }
+    }
+}
+// Registry of step executors
+const executors = new Map();
+// Register built-in executors (no optional deps: no image here; see step-executor-image)
+executors.set('bash', new BashStepExecutor());
+executors.set('file', new FileStepExecutor());
+executors.set('api', new ApiStepExecutor());
+executors.set('script', new ScriptStepExecutor());
+export function getStepExecutor(type) {
+    return Promise.resolve(executors.get(type));
+}
+export function registerStepExecutor(executor) {
+    executors.set(executor.type, executor);
+}
+export async function executeStep(step, context) {
+    const executor = await getStepExecutor(step.type);
+    if (!executor) {
+        return {
+            success: false,
+            error: `No executor found for step type: ${step.type}`,
+            duration: 0
+        };
+    }
+    return executor.execute(step, context);
+}
+//# sourceMappingURL=step-executor.js.map

package/dist/utils/templates.d.ts

@@ -9,4 +9,5 @@ export declare const improvementTemplate = "# Improvement Actions: {{taskId}}\n\
 export declare const resourcesTemplate = "# Resources: {{description}}\n\n## People / Roles\n<!-- Who is needed for this task? -->\n-\n\n## Tools & Systems\n<!-- What tools, systems, or infrastructure is required? -->\n-\n\n## Data Requirements\n<!-- What data or information is needed? -->\n-\n\n## Time Estimate\n<!-- Estimated effort and timeline -->\n- Effort:\n- Timeline:\n";
 export declare const standardizationTemplate = "# Standardization: {{taskId}}\n\n## Successful Practices\n<!-- Document practices that worked well -->\n\n## Reusable Patterns\n<!-- Patterns that can be reused -->\n\n## Standard Operating Procedures\n<!-- Document SOPs if applicable -->\n";
 export declare function renderTemplate(template: string, vars: Record<string, string>): string;
+export declare const pipelineConfigTemplate = "# Pipeline Configuration\n# This file controls automated PDCA cycle execution\n\nversion: \"1.0\"\n\nphases:\n  # Do phase: Execute tasks and collect data\n  do:\n    auto: true              # Enable automatic execution\n    parallel: false         # Execute tasks sequentially (set to true for concurrent)\n    maxConcurrency: 4       # Max concurrent tasks when parallel is true\n    successCriteria:\n      minTasksCompleted: \"100%\"  # Percentage or absolute number required\n\n  # Check phase: Evaluate results and analyze deviations\n  check:\n    auto: true              # Enable automatic comparison\n    analyze: true           # Perform root cause analysis\n    recommend: true         # Generate recommendations\n    successCriteria:\n      allowPartialGoals: true    # Continue even if some goals are partial\n      allowUnmetGoals: false     # Fail if any goals are unmet (set to true to allow)\n\n  # Act phase: Process results and take improvement actions\n  act:\n    auto: true              # Enable automatic processing\n    standardize: true       # Document successful practices\n    carryForward: true      # Generate next cycle items for unresolved issues\n    completeOnSuccess: true # Mark task as completed when pipeline succeeds\n";
 //# sourceMappingURL=templates.d.ts.map

package/dist/utils/templates.js

@@ -140,4 +140,34 @@ export function renderTemplate(template, vars) {
     }
     return result;
 }
+export const pipelineConfigTemplate = `# Pipeline Configuration
+# This file controls automated PDCA cycle execution
+
+version: "1.0"
+
+phases:
+  # Do phase: Execute tasks and collect data
+  do:
+    auto: true              # Enable automatic execution
+    parallel: false         # Execute tasks sequentially (set to true for concurrent)
+    maxConcurrency: 4       # Max concurrent tasks when parallel is true
+    successCriteria:
+      minTasksCompleted: "100%"  # Percentage or absolute number required
+
+  # Check phase: Evaluate results and analyze deviations
+  check:
+    auto: true              # Enable automatic comparison
+    analyze: true           # Perform root cause analysis
+    recommend: true         # Generate recommendations
+    successCriteria:
+      allowPartialGoals: true    # Continue even if some goals are partial
+      allowUnmetGoals: false     # Fail if any goals are unmet (set to true to allow)
+
+  # Act phase: Process results and take improvement actions
+  act:
+    auto: true              # Enable automatic processing
+    standardize: true       # Document successful practices
+    carryForward: true      # Generate next cycle items for unresolved issues
+    completeOnSuccess: true # Mark task as completed when pipeline succeeds
+`;
 //# sourceMappingURL=templates.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmddev/tmd",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Task Markdown Driven - A lightweight PDCA cycle management framework integrated with OpenSpec",
   "type": "module",
   "publishConfig": {
@@ -27,23 +27,6 @@
     "!dist/**/__tests__",
     "!dist/**/*.map"
   ],
-  "scripts": {
-    "lint": "eslint src/",
-    "build": "tsx build.ts",
-    "dev": "tsc --watch",
-    "dev:cli": "pnpm build && node bin/tmd.js",
-    "test": "vitest run",
-    "test:watch": "vitest",
-    "test:ui": "vitest --ui",
-    "test:coverage": "vitest --coverage",
-    "prepare": "pnpm run build",
-    "prepublishOnly": "pnpm run build",
-    "postinstall": "node scripts/postinstall.js",
-    "check:pack-version": "node scripts/pack-version-check.mjs",
-    "release": "pnpm run release:ci",
-    "release:ci": "pnpm run check:pack-version",
-    "changeset": "changeset"
-  },
   "keywords": [
     "pdca",
     "openspec",
@@ -60,7 +43,7 @@
     "url": "https://github.com/sdd330/tmd.git"
   },
   "author": "TMD Contributors",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "dependencies": {
     "commander": "^13.1.0",
     "js-yaml": "^4.1.0",
@@ -79,6 +62,24 @@
     "vitest": "^3.2.4"
   },
   "engines": {
-    "node": ">=20.19.0"
+    "node": ">=20.19.0",
+    "bun": ">=1.0"
+  },
+  "scripts": {
+    "lint": "eslint src/",
+    "build": "tsx build.ts",
+    "build:native": "node scripts/build-native.mjs",
+    "dev": "tsc --watch",
+    "dev:cli": "pnpm build && node bin/tmd.js",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:ui": "vitest --ui",
+    "test:coverage": "vitest --coverage",
+    "postinstall": "node scripts/postinstall.js || bun scripts/postinstall.js",
+    "check:pack-version": "node scripts/pack-version-check.mjs",
+    "check:docs-english": "node scripts/check-docs-english.mjs",
+    "release": "pnpm run release:ci",
+    "release:ci": "pnpm run check:pack-version",
+    "changeset": "changeset"
   }
-}
+}

package/scripts/postinstall.js

@@ -1,22 +1,25 @@
 #!/usr/bin/env node
 
 /**
- * Postinstall script for TMD
+ * Postinstall script for TMD. Supports Node and Bun (fs, path, process.env are compatible).
  *
- * This script runs automatically after npm install unless:
- * - CI=true environment variable is set
- * - TMD_NO_POSTINSTALL=1 environment variable is set
- * - dist/ directory doesn't exist (dev setup scenario)
+ * Runs after npm/pnpm/bun install unless:
+ * - CI=true
+ * - TMD_NO_POSTINSTALL=1
+ * - dist/ does not exist (dev setup)
  *
- * The script never fails npm install - all errors are caught and handled gracefully.
+ * Never fails the install; errors are caught and handled.
  */
 
 import { promises as fs } from 'fs';
 import path from 'path';
 import { fileURLToPath } from 'url';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+// Bun: import.meta.dirname; Node: derive from import.meta.url
+const __dirname =
+  typeof import.meta.dirname === 'string'
+    ? import.meta.dirname
+    : path.dirname(fileURLToPath(import.meta.url));
 
 /**
  * Check if we should skip installation