@tmddev/tmd 0.1.0 → 0.2.0

package/README.md

@@ -9,7 +9,9 @@
 <p align="center">
   <a href="https://tmdd.dev"><img alt="Website" src="https://img.shields.io/badge/Website-tmdd.dev-blue?style=flat-square" /></a>
   <a href="https://github.com/sdd330/tmd/actions/workflows/ci.yml"><img alt="CI" src="https://github.com/sdd330/tmd/actions/workflows/ci.yml/badge.svg" /></a>
-  <a href="./LICENSE"><img alt="License: MIT" src="https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square" /></a>
+  <a href="https://www.npmjs.com/package/@tmddev/tmd"><img alt="npm version" src="https://img.shields.io/npm/v/@tmddev/tmd?style=flat-square" /></a>
+  <a href="https://nodejs.org/"><img alt="node version" src="https://img.shields.io/node/v/@tmddev/tmd?style=flat-square" /></a>
+  <a href="./LICENSE"><img alt="License: Apache-2.0" src="https://img.shields.io/badge/License-Apache%202.0-blue.svg?style=flat-square" /></a>
   <a href="https://conventionalcommits.org"><img alt="Conventional Commits" src="https://img.shields.io/badge/Conventional%20Commits-1.0.0-yellow.svg?style=flat-square" /></a>
 </p>
 
@@ -34,9 +36,11 @@ At the core of TMD is the principle that tasks should be **pee-break (10 seconds
 ## Features
 
 - **PDCA Cycle Management**: Four-phase commands for Plan, Do, Check, and Act
+- **Pipe Execution**: Automated PDCA cycles without human input for CI/CD and AI agent workflows
 - **Ten sec to Ten min Task!**: Tasks are designed to be pee-break (10 seconds to 10 minutes) sized for quick completion
 - **OpenSpec Integration**: Automatic creation and linking of OpenSpec change proposals
 - **Skills System**: Reusable capabilities for AI agents with cross-agent invocation support
+- **Step Executors**: Built-in executors for bash commands, file operations, and API calls
 - **English Language Standard**: All documents and specifications use English
 - **Markdown-Based**: All documentation stored in Markdown format
 - **CLI Interface**: Simple command-line interface with aliases
@@ -44,7 +48,7 @@ At the core of TMD is the principle that tasks should be **pee-break (10 seconds
 ## Installation
 
 ### Prerequisites
-- **Node.js >= 20.19.0** - Check your version with `node --version`
+- **Node.js >= 20.19.0** or **Bun >= 1.0** — Check with `node --version` or `bun --version`
 
 ### Install the CLI globally
 
@@ -72,6 +76,38 @@ pnpm run build
 pnpm link --global  # Optional: link for local development
 ```
 
+**Option D: Using Bun**
+```bash
+bun install -g @tmddev/tmd@latest
+# or run without global install:
+bun x @tmddev/tmd --version
+bun run tmd --help   # when in a project with @tmddev/tmd as a dependency
+```
+In the TMD repo: `bun install`, `bun run build`, `bun run test`, and `bun ./bin/tmd.js --version` are all supported.
+
+### Install from source
+
+**Prerequisites:** Node.js >=20.19.0 or Bun >=1.0, pnpm, [Rust](https://rustup.rs/) (for the `tmd-skills` binary), git.
+
+```bash
+git clone https://github.com/sdd330/tmd.git
+cd tmd
+pnpm install
+pnpm build          # includes the tmd-skills native binary
+pnpm link --global  # optional: use `tmd` from this build
+```
+
+Optional:
+
+- **`pnpm build:native`** — Rebuild only the `tmd-skills` Rust binary (faster when only Rust code changed).
+- **`./bin/agent-browser install`** — When using the agent-browser skill, install the agent-browser CLI if this script is provided (e.g. by the agent-browser project; skip if not present).
+
+Example: add the `pdf` skill from [anthropics/skills](https://github.com/anthropics/skills) and symlink to all detected agents:
+
+```bash
+tmd skills add anthropics/skills --github --skill pdf --all
+```
+
 ## Quick Start
 
 ### 1. Create a Plan
@@ -162,6 +198,18 @@ This principle ensures tasks are:
 
 ## Commands
 
+### Setup and Dashboard
+
+- `tmd init [path]` - Initialize TMD in your project (creates `tmd/` and `schemas/pdca/` when missing; default path `.`)
+- `tmd view` - Display a dashboard of tasks by phase and status
+- `tmd validate [task-id]` - Validate task documents or PDCA schemas
+  - `--schemas [name]` - Validate schemas only (name optional)
+  - `--all` - Validate all tasks and schemas
+  - `--strict` - Stricter checks (e.g. task size)
+  - `--json` - Output as JSON
+- `tmd schemas` - List available workflow schemas
+  - `--json` - Output as JSON
+
 ### PDCA Commands
 
 - `tmd plan <description>` / `tmdp` - Create a new plan
@@ -190,12 +238,28 @@ This principle ensures tasks are:
 
 - `tmd show <task-id>` - Show task details
 
+### Pipe (Automated PDCA)
+
+- `tmd pipe init <task-id>` - Initialize pipe configuration
+  - `--force` - Overwrite existing configuration
+
+- `tmd pipe run <task-id>` - Run full PDCA cycle automatically
+  - `--from <phase>` - Start from specific phase (do, check, act)
+  - `--dry-run` - Preview execution without making changes
+
+- `tmd pipe status <task-id>` - Show pipe execution state
+  - `--json` - Output in JSON format
+
 ### Skills Management
 
 - `tmd skills list` - List all available skills
+  - `--tag <tag>` - Filter by tag (repeatable, OR semantics)
 - `tmd skills search <query>` - Search skills
 - `tmd skills show <skill-name>` - Show skill details
 - `tmd skills invoke <skill-name> --input <params>` - Invoke a skill
+- `tmd skills create <name>` - Create a skill (optionally `--description <desc>`, `--tags <t1,t2>`)
+- `tmd skills update <name>` - Update metadata (`--description <desc>`, `--tags <t1,t2>`; at least one required)
+- `tmd skills remove <name>` - Remove a skill (`--force` to skip confirmation)
 
 ## Skills System
 
@@ -244,6 +308,94 @@ Skills can be invoked by any AI agent:
 tmd skill invoke generate-readme-multilang --input "template_path=README.md target_languages=[zh,es,fr]"
 ```
 
+## Pipe Execution
+
+Pipe execution enables fully automated PDCA cycles without human intervention - ideal for CI/CD integration and AI agent workflows.
+
+### Initialize Pipe
+
+```bash
+tmd pipe init <task-id>
+```
+
+This creates a `pipeline.yaml` configuration file in the task's plan directory with customizable settings for each phase.
+
+### Run Full Pipe
+
+```bash
+tmd pipe run <task-id>
+```
+
+This automatically executes:
+1. **Do phase**: Executes all tasks, runs skill steps, captures output
+2. **Check phase**: Compares results against goals, analyzes deviations
+3. **Act phase**: Processes results, generates improvements, marks task complete
+
+### Pipeline Configuration
+
+```yaml
+# pipeline.yaml
+version: "1.0"
+phases:
+  do:
+    auto: true
+    parallel: false
+    maxConcurrency: 4
+    successCriteria:
+      minTasksCompleted: "100%"
+  check:
+    auto: true
+    analyze: true
+    recommend: true
+  act:
+    auto: true
+    standardize: true
+    carryForward: true
+    completeOnSuccess: true
+```
+
+### Step Executors
+
+Pipeline supports three step types for automated task execution:
+
+- **bash**: Execute shell commands
+  ```yaml
+  - type: bash
+    command: "npm run build"
+  ```
+
+- **file**: File operations (read, write, copy, delete)
+  ```yaml
+  - type: file
+    operation: write
+    path: output.txt
+    content: "Hello World"
+  ```
+
+- **api**: HTTP requests
+  ```yaml
+  - type: api
+    url: "https://api.example.com/data"
+    method: POST
+    body: { "key": "value" }
+  ```
+
+### Dry Run Mode
+
+Preview pipe execution without making changes:
+
+```bash
+tmd pipe run <task-id> --dry-run
+```
+
+### Resume from Phase
+
+Start from a specific phase (useful for recovering from failures):
+
+```bash
+tmd pipe run <task-id> --from check
+```
+
 ## OpenSpec Integration
 
 TMD automatically integrates with OpenSpec projects:
@@ -328,6 +480,46 @@ tmd plan "Generate README for new project" --use-skill generate-readme-multilang
 tmd do <task-id> --skill generate-readme-multilang
 ```
 
+### Example 3: Automated Pipe
+
+```bash
+# Create a plan with tasks
+tmd plan "Build and deploy application"
+
+# Initialize pipe configuration
+tmd pipe init 20260123-build-and-deploy-application
+
+# Preview what will happen (dry run)
+tmd pipe run 20260123-build-and-deploy-application --dry-run
+
+# Run the full automated PDCA cycle
+tmd pipe run 20260123-build-and-deploy-application
+
+# Check pipe status
+tmd pipe status 20260123-build-and-deploy-application
+```
+
+Output:
+```
+Pipe: 20260123-build-and-deploy-application
+──────────────────────────────────────────────────
+
+  Phase: DO
+    Tasks to execute: 5/5
+  Phase do completed
+
+  Phase: CHECK
+    Goals met: 3/3
+  Phase check completed
+
+  Phase: ACT
+    Task marked as completed
+  Phase act completed
+──────────────────────────────────────────────────
+
+Pipe completed successfully
+```
+
 ## Language Standard
 
 All documents and specifications use English. The system:
@@ -421,4 +613,4 @@ See [MAINTAINERS.md](MAINTAINERS.md) for maintainer information.
 
 ## License
 
-MIT
+Apache-2.0

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
-import { createRequire } from 'module';
+import { readFileSync } from 'fs';
 import { fileURLToPath } from 'url';
 import { dirname, join } from 'path';
 import { planCommand } from './commands/plan.js';
@@ -10,20 +10,46 @@ import { actCommand } from './commands/act.js';
 import { listCommand } from './commands/list.js';
 import { showCommand } from './commands/show.js';
 import { skillsCommand } from './commands/skills.js';
+import { pipelineInitCommand, pipelineRunCommand, pipelineStatusCommand } from './commands/pipeline.js';
+import { initCommand } from './commands/init.js';
+import { viewCommand } from './commands/view.js';
+import { validateCommand } from './commands/validate.js';
+import { schemasCommand } from './commands/schemas.js';
 const program = new Command();
-// Use fileURLToPath to resolve package.json relative to project root
-// When running from bin/tmd.js -> dist/cli.js, we need to go up from dist/ to project root
-const require = createRequire(import.meta.url);
+// Resolve project root: bin/tmd.js -> dist/cli.js -> dist/ -> project root
 const __filename = fileURLToPath(import.meta.url);
-// dist/cli.js -> dist/ -> project root
 const projectRoot = dirname(dirname(__filename));
 const packageJsonPath = join(projectRoot, 'package.json');
-const pkg = require(packageJsonPath);
+const pkg = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
 const { version } = pkg;
 program
     .name('tmd')
     .description('Task Markdown Driven - PDCA cycle management framework')
     .version(version);
+// Init
+program
+    .command('init')
+    .description('Initialize TMD in your project')
+    .argument('[path]', 'Target path', '.')
+    .action((pathArg) => { initCommand(pathArg); });
+program
+    .command('view')
+    .description('Display a dashboard of tasks by phase and status')
+    .action(viewCommand);
+program
+    .command('validate')
+    .description('Validate task documents or PDCA schemas')
+    .argument('[task-id]', 'Task ID to validate')
+    .option('--schemas [name]', 'Validate schemas only (name optional)')
+    .option('--all', 'Validate all tasks and schemas')
+    .option('--strict', 'Stricter checks (e.g. task size)')
+    .option('--json', 'Output as JSON')
+    .action((taskId, opts) => { validateCommand(taskId, opts); });
+program
+    .command('schemas')
+    .description('List available workflow schemas')
+    .option('--json', 'Output as JSON')
+    .action((opts) => { schemasCommand(opts); });
 // PDCA commands
 program
     .command('plan')
@@ -83,10 +109,44 @@ program
 // Skills commands
 program
     .command('skills')
-    .description('Manage skills')
-    .argument('[action]', 'Action: list, search, show, invoke')
-    .argument('[name]', 'Skill name or search query')
+    .description('Manage skills (list, search, show, invoke, add, create, update, remove)')
+    .argument('[action]', 'Action: list, search, show, invoke, add, create, update, remove')
+    .argument('[name]', 'Skill name, search query, or repository (owner/repo)')
     .option('--input <params>', 'Input parameters for invoke')
-    .action(skillsCommand);
+    .option('--skill <skill-name>', 'Skill name when adding from repository')
+    .option('--description <desc>', 'Description for create/update')
+    .option('--tags <t1,t2>', 'Comma-separated tags for create/update')
+    .option('--tag <tag>', 'Filter list by tag (repeatable)', (v, prev) => (prev ?? []).concat([v]))
+    .option('--force', 'Remove without confirmation, or overwrite existing skill on add')
+    .option('--all', 'With remove: also delete agent/IDE links. With create/add/update: also create symlinks under .cursor, .agents, .codex, .opencode, etc. so the skill is available to those IDEs')
+    .option('--github', 'Import skill from GitHub repository (not skills.sh)')
+    .option('--branch <branch>', 'GitHub branch to fetch from (default: main/master)')
+    .option('--path <path>', 'Custom path to skill file in repository')
+    .action(function (action, name) {
+    void skillsCommand(action, name, this.opts());
+});
+// Pipeline commands
+const pipe = program
+    .command('pipe')
+    .description('Automated PDCA pipeline execution');
+pipe
+    .command('init')
+    .description('Initialize pipe configuration for a task')
+    .argument('<task-id>', 'Task ID')
+    .option('--force', 'Overwrite existing configuration')
+    .action(pipelineInitCommand);
+pipe
+    .command('run')
+    .description('Run the PDCA pipe for a task')
+    .argument('<task-id>', 'Task ID')
+    .option('--from <phase>', 'Start from specific phase (do, check, act)')
+    .option('--dry-run', 'Preview execution without making changes')
+    .action(pipelineRunCommand);
+pipe
+    .command('status')
+    .description('Show pipe status for a task')
+    .argument('<task-id>', 'Task ID')
+    .option('--json', 'Output in JSON format')
+    .action(pipelineStatusCommand);
 program.parse();
 //# sourceMappingURL=cli.js.map

package/dist/commands/init.d.ts

@@ -0,0 +1,2 @@
+export declare function initCommand(pathArg?: string): void;
+//# sourceMappingURL=init.d.ts.map

package/dist/commands/init.js

@@ -0,0 +1,60 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import chalk from 'chalk';
+import { ensureDir, getSchemasDir, getTmdDir } from '../utils/paths.js';
+const MINIMAL_PDCA_SCHEMA = `name: pdca
+version: 1
+description: PDCA (Plan-Do-Check-Act) cycle workflow for task management
+artifacts:
+  - id: plan
+    generates: plan.md
+    description: Planning document
+    template: plan.md
+    requires: []
+  - id: do
+    generates: execution.md
+    description: Execution log
+    template: execution.md
+    requires: [plan]
+  - id: check
+    generates: evaluation.md
+    description: Evaluation and deviation analysis
+    template: evaluation.md
+    requires: [do]
+  - id: act
+    generates: improvement.md
+    description: Improvement and standardization
+    template: improvement.md
+    requires: [check]
+apply:
+  requires: [plan]
+  tracks: plan.md
+`;
+export function initCommand(pathArg) {
+    const targetPath = join(process.cwd(), pathArg ?? '.');
+    if (!existsSync(targetPath)) {
+        mkdirSync(targetPath, { recursive: true });
+    }
+    const tmdDir = join(targetPath, getTmdDir());
+    const schemasPdcaDir = join(targetPath, getSchemasDir(), 'pdca');
+    const schemaPath = join(schemasPdcaDir, 'schema.yaml');
+    ensureDir(tmdDir);
+    ensureDir(schemasPdcaDir);
+    if (!existsSync(schemaPath)) {
+        // Bun: import.meta.dirname; Node: derive from import.meta.url
+        const __dirname = typeof import.meta.dirname === 'string'
+            ? import.meta.dirname
+            : dirname(fileURLToPath(import.meta.url));
+        const packageRoot = join(__dirname, '..', '..');
+        const builtin = join(packageRoot, 'schemas', 'pdca', 'schema.yaml');
+        if (existsSync(builtin)) {
+            writeFileSync(schemaPath, readFileSync(builtin, 'utf-8'));
+        }
+        else {
+            writeFileSync(schemaPath, MINIMAL_PDCA_SCHEMA);
+        }
+    }
+    console.log(chalk.green('TMD initialized'));
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/pipeline.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Pipeline command handlers for automated PDCA execution
+ */
+export interface PipelineInitOptions {
+    force?: boolean;
+}
+export interface PipelineRunOptions {
+    from?: string;
+    dryRun?: boolean;
+}
+export interface PipelineStatusOptions {
+    json?: boolean;
+}
+/**
+ * Initialize pipeline configuration for a task
+ */
+export declare function pipelineInitCommand(taskId: string, options: PipelineInitOptions): void;
+/**
+ * Run the pipeline for a task
+ */
+export declare function pipelineRunCommand(taskId: string, options: PipelineRunOptions): Promise<void>;
+/**
+ * Show pipeline status for a task
+ */
+export declare function pipelineStatusCommand(taskId: string, options: PipelineStatusOptions): void;
+//# sourceMappingURL=pipeline.d.ts.map

package/dist/commands/pipeline.js

@@ -0,0 +1,168 @@
+/**
+ * Pipeline command handlers for automated PDCA execution
+ */
+import { existsSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { getPlanDir, ensureDir } from '../utils/paths.js';
+import { loadPipelineConfig, generatePipelineConfigTemplate, getPipelineConfigPath, DEFAULT_PIPELINE_CONFIG } from '../utils/pipeline-config.js';
+import { PipelineRunner, getPipelineState } from '../utils/pipeline.js';
+import { writeFileSync } from 'fs';
+/**
+ * Initialize pipeline configuration for a task
+ */
+export function pipelineInitCommand(taskId, options) {
+    const planPath = join(getPlanDir(taskId), 'plan.md');
+    if (!existsSync(planPath)) {
+        console.error(chalk.red(`Error: Plan not found for task: ${taskId}`));
+        process.exit(1);
+    }
+    const configPath = getPipelineConfigPath(taskId);
+    if (existsSync(configPath) && !options.force) {
+        console.log(chalk.yellow(`Pipe config already exists: ${configPath}`));
+        console.log(chalk.gray('Use --force to overwrite'));
+        return;
+    }
+    const configContent = generatePipelineConfigTemplate();
+    ensureDir(getPlanDir(taskId));
+    writeFileSync(configPath, configContent);
+    console.log(chalk.green(`Created pipeline configuration: ${configPath}`));
+    console.log(chalk.gray('\nDefault settings:'));
+    console.log(chalk.gray('  - Do phase: auto execution enabled'));
+    console.log(chalk.gray('  - Check phase: auto comparison with analysis'));
+    console.log(chalk.gray('  - Act phase: auto processing with standardization'));
+    console.log(chalk.gray('\nEdit pipeline.yaml to customize behavior.'));
+}
+/**
+ * Run the pipeline for a task
+ */
+export async function pipelineRunCommand(taskId, options) {
+    const planPath = join(getPlanDir(taskId), 'plan.md');
+    if (!existsSync(planPath)) {
+        console.error(chalk.red(`Error: Plan not found for task: ${taskId}`));
+        process.exit(1);
+    }
+    // Load config or use defaults
+    let config = loadPipelineConfig(taskId);
+    if (!config) {
+        console.log(chalk.yellow('No pipeline.yaml found, using default configuration'));
+        config = DEFAULT_PIPELINE_CONFIG;
+    }
+    // Validate --from option
+    const validPhases = ['do', 'check', 'act'];
+    let fromPhase;
+    if (options.from) {
+        if (!validPhases.includes(options.from)) {
+            console.error(chalk.red(`Error: Invalid phase: ${options.from}`));
+            console.error(chalk.gray(`Valid phases: ${validPhases.join(', ')}`));
+            process.exit(1);
+        }
+        fromPhase = options.from;
+    }
+    // Create and run pipeline
+    const runner = new PipelineRunner(taskId, config, options.dryRun);
+    console.log(chalk.blue(`\nPipe: ${taskId}`));
+    if (options.dryRun) {
+        console.log(chalk.yellow('Mode: DRY RUN (no changes will be made)'));
+    }
+    if (fromPhase) {
+        console.log(chalk.gray(`Starting from: ${fromPhase}`));
+    }
+    console.log(chalk.gray('─'.repeat(50)));
+    const result = await runner.run(fromPhase);
+    console.log(chalk.gray('─'.repeat(50)));
+    if (result.success) {
+        console.log(chalk.green('\nPipe completed successfully'));
+        displayPipelineSummary(result);
+    }
+    else {
+        console.log(chalk.red(`\nPipe failed: ${result.error ?? ''}`));
+        displayPipelineSummary(result);
+        process.exit(1);
+    }
+}
+/**
+ * Show pipeline status for a task
+ */
+export function pipelineStatusCommand(taskId, options) {
+    const planPath = join(getPlanDir(taskId), 'plan.md');
+    if (!existsSync(planPath)) {
+        console.error(chalk.red(`Error: Plan not found for task: ${taskId}`));
+        process.exit(1);
+    }
+    const state = getPipelineState(taskId);
+    const config = loadPipelineConfig(taskId);
+    if (options.json) {
+        console.log(JSON.stringify({
+            taskId,
+            state,
+            hasConfig: !!config
+        }, null, 2));
+        return;
+    }
+    console.log(chalk.blue(`\nPipe Status: ${taskId}`));
+    console.log(chalk.gray('─'.repeat(50)));
+    // Config status
+    console.log(chalk.gray('\nConfiguration:'));
+    if (config) {
+        console.log(chalk.green('  pipeline.yaml: found'));
+    }
+    else {
+        console.log(chalk.yellow('  pipeline.yaml: not found (will use defaults)'));
+    }
+    // Phase status
+    console.log(chalk.gray('\nPhases:'));
+    const phases = ['do', 'check', 'act'];
+    for (const phase of phases) {
+        const completed = state.completedPhases.includes(phase);
+        const current = state.currentPhase === phase;
+        let status;
+        let color;
+        if (completed) {
+            status = 'completed';
+            color = chalk.green;
+        }
+        else if (current) {
+            status = 'in progress';
+            color = chalk.yellow;
+        }
+        else {
+            status = 'pending';
+            color = chalk.gray;
+        }
+        const indicator = completed ? '✓' : current ? '→' : '○';
+        console.log(color(`  ${indicator} ${phase.toUpperCase()}: ${status}`));
+    }
+    // Last run info
+    if (state.lastRun) {
+        console.log(chalk.gray(`\nLast run: ${state.lastRun.toISOString()}`));
+    }
+    if (state.lastError) {
+        console.log(chalk.red(`\nLast error: ${state.lastError}`));
+    }
+    console.log('');
+}
+/**
+ * Display pipeline execution summary
+ */
+function displayPipelineSummary(result) {
+    if (result.phases.length === 0) {
+        return;
+    }
+    console.log(chalk.gray('\nPhase Summary:'));
+    for (const phase of result.phases) {
+        const duration = phase.endTime.getTime() - phase.startTime.getTime();
+        const status = phase.success ? chalk.green('✓') : chalk.red('✗');
+        const durationStr = duration < 1000 ? `${String(duration)}ms` : `${(duration / 1000).toFixed(1)}s`;
+        console.log(`  ${status} ${phase.phase.toUpperCase()} (${durationStr})`);
+        if (phase.details) {
+            for (const [key, value] of Object.entries(phase.details)) {
+                console.log(chalk.gray(`      ${key}: ${String(value)}`));
+            }
+        }
+        if (phase.error) {
+            console.log(chalk.red(`      Error: ${phase.error}`));
+        }
+    }
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/commands/schemas.d.ts

@@ -0,0 +1,4 @@
+export declare function schemasCommand(opts?: {
+    json?: boolean;
+}): void;
+//# sourceMappingURL=schemas.d.ts.map