@tmddev/tmd 0.3.0 → 0.3.2

package/dist/commands/ui.js

@@ -0,0 +1,33 @@
+import { spawnSync } from 'child_process';
+import { existsSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+import { ensureProjectDirs } from '../utils/paths.js';
+const DESKTOP_NOT_FOUND = 'Desktop app not found. Build with: pnpm --filter tmd-desktop tauri build';
+export function uiCommand() {
+    const projectRoot = process.cwd();
+    ensureProjectDirs(projectRoot);
+    const __filename = fileURLToPath(import.meta.url);
+    const distCommands = dirname(__filename);
+    const distDir = dirname(distCommands);
+    const repoRoot = dirname(distDir);
+    const appsDesktop = join(repoRoot, 'apps', 'desktop');
+    if (!existsSync(join(appsDesktop, 'package.json'))) {
+        console.error(DESKTOP_NOT_FOUND);
+        process.exit(1);
+    }
+    // Prefer: pnpm exec tauri dev in apps/desktop with TMD_PROJECT_ROOT
+    const env = { ...process.env, TMD_PROJECT_ROOT: projectRoot };
+    const r = spawnSync('pnpm', ['exec', 'tauri', 'dev'], {
+        cwd: appsDesktop,
+        env,
+        stdio: 'inherit',
+    });
+    if (r.error) {
+        console.error(DESKTOP_NOT_FOUND);
+        console.error(r.error.message);
+        process.exit(1);
+    }
+    process.exit(r.status ?? 1);
+}
+//# sourceMappingURL=ui.js.map

package/dist/commands/validate.js

@@ -2,6 +2,7 @@ import { existsSync, readdirSync, readFileSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
 import yaml from 'js-yaml';
+import { validateExecutionPlan } from '../utils/execution-plan.js';
 import { getPlanDir, getDoDir, getCheckDir, getActDir, getSchemasDir, getTmdDir, } from '../utils/paths.js';
 import { getTaskStatus } from '../utils/task-status.js';
 function getBase() {
@@ -10,6 +11,7 @@ function getBase() {
 function validateTask(taskId, base, strict) {
     const issues = [];
     const planPath = join(base, getPlanDir(taskId), 'plan.md');
+    const execPlanPath = join(base, getPlanDir(taskId), 'execution-plan.json');
     if (!existsSync(planPath)) {
         issues.push({ level: 'error', path: 'plan.md', message: 'plan.md not found' });
         return { taskId, valid: false, issues };
@@ -49,6 +51,35 @@ function validateTask(taskId, base, strict) {
                 issues.push({ level: 'warning', path: 'plan.md', message: 'Tasks section has no checklist items' });
             }
         }
+        // Execution plan dependency validation (strict mode)
+        if (existsSync(execPlanPath)) {
+            try {
+                const raw = readFileSync(execPlanPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                const execIssues = validateExecutionPlan(parsed);
+                for (const it of execIssues) {
+                    issues.push({
+                        level: it.level === 'error' ? 'error' : 'warning',
+                        path: 'execution-plan.json',
+                        message: it.message,
+                    });
+                }
+            }
+            catch (e) {
+                issues.push({
+                    level: 'error',
+                    path: 'execution-plan.json',
+                    message: `Failed to parse execution-plan.json: ${e.message}`,
+                });
+            }
+        }
+        else {
+            issues.push({
+                level: 'warning',
+                path: 'execution-plan.json',
+                message: 'execution-plan.json not found (no execution plan artifact)',
+            });
+        }
     }
     const hasError = issues.some((i) => i.level === 'error');
     return { taskId, valid: !hasError, issues };

package/dist/types.d.ts

@@ -2,10 +2,12 @@
  * Shared type definitions for TMD CLI
  */
 export interface PlanCommandOptions {
-    openspec?: boolean;
+    agentId?: string | undefined;
     skill?: boolean;
     useSkill?: string;
     validateTasks?: boolean;
+    strictDeps?: boolean;
+    assignAgent?: string;
 }
 export interface DoCommandOptions {
     data?: string;
@@ -35,6 +37,10 @@ export interface ListCommandOptions {
 export interface SkillsCommandOptions {
     input?: string;
     skill?: string;
+    agent?: string[];
+    global?: boolean;
+    yes?: boolean;
+    list?: boolean;
     description?: string;
     tags?: string;
     tag?: string[];
@@ -57,7 +63,7 @@ export interface SkillMetadata {
     version?: string;
     description?: string;
     tags?: string[];
-    source?: 'skillssh' | 'local' | 'github';
+    source?: 'local' | 'github' | 'zip' | 'skills-cli';
     repo?: string;
     branch?: string;
     importedAt?: string;

package/dist/utils/execution-plan.d.ts

@@ -0,0 +1,56 @@
+export type ExecutionPlanNodeStatus = 'pending' | 'running' | 'done' | 'failed';
+export interface ExecutionPlanNode {
+    id: string;
+    title: string;
+    status?: ExecutionPlanNodeStatus;
+    agentId?: string;
+}
+export interface ExecutionPlanEdge {
+    id: string;
+    source: string;
+    target: string;
+}
+export interface ExecutionPlan {
+    version: string;
+    taskId: string;
+    nodes: ExecutionPlanNode[];
+    edges: ExecutionPlanEdge[];
+    meta?: Record<string, unknown>;
+}
+export interface ExecutionPlanValidationIssue {
+    level: 'error' | 'warning';
+    message: string;
+}
+export declare function buildExecutionPlan(opts: {
+    taskId: string;
+    nodes: Array<{
+        id: string;
+        title: string;
+        agentId?: string;
+    }>;
+    edges: Array<{
+        source: string;
+        target: string;
+    }>;
+    version?: string;
+    meta?: Record<string, unknown>;
+}): ExecutionPlan;
+/**
+ * Convert tmd-plan generated tasks into an execution plan.
+ *
+ * Note:
+ * - The Rust generator may emit `dependencies` as 0-based task indexes.
+ * - In the persisted execution plan artifact, task dependencies are represented
+ *   ONLY by `edges` (source -> target).
+ */
+export declare function executionPlanFromGeneratedTasks(opts: {
+    taskId: string;
+    tasks: Array<{
+        title: string;
+        dependencies?: number[] | undefined;
+    }>;
+    defaultAgentId?: string;
+    generatedBy?: string;
+}): ExecutionPlan;
+export declare function validateExecutionPlan(plan: ExecutionPlan): ExecutionPlanValidationIssue[];
+//# sourceMappingURL=execution-plan.d.ts.map

package/dist/utils/execution-plan.js

@@ -0,0 +1,109 @@
+export function buildExecutionPlan(opts) {
+    const version = opts.version ?? '1';
+    const nodes = opts.nodes.map((n) => {
+        const node = {
+            id: n.id,
+            title: n.title,
+            status: 'pending',
+        };
+        if (n.agentId !== undefined)
+            node.agentId = n.agentId;
+        return node;
+    });
+    const edges = opts.edges.map((e) => ({
+        id: `e-${e.source}-${e.target}`,
+        source: e.source,
+        target: e.target,
+    }));
+    const plan = { version, taskId: opts.taskId, nodes, edges };
+    if (opts.meta !== undefined)
+        plan.meta = opts.meta;
+    return plan;
+}
+/**
+ * Convert tmd-plan generated tasks into an execution plan.
+ *
+ * Note:
+ * - The Rust generator may emit `dependencies` as 0-based task indexes.
+ * - In the persisted execution plan artifact, task dependencies are represented
+ *   ONLY by `edges` (source -> target).
+ */
+export function executionPlanFromGeneratedTasks(opts) {
+    const agentId = opts.defaultAgentId ?? 'executor';
+    const nodes = opts.tasks.map((t, i) => ({
+        id: `task-${String(i + 1)}`,
+        title: t.title,
+        agentId,
+    }));
+    const edges = [];
+    for (let i = 0; i < opts.tasks.length; i++) {
+        const deps = opts.tasks[i]?.dependencies ?? [];
+        for (const d of deps) {
+            // Rust generator uses 0-based indices
+            const source = `task-${String(d + 1)}`;
+            const target = `task-${String(i + 1)}`;
+            edges.push({ source, target });
+        }
+    }
+    return buildExecutionPlan({
+        taskId: opts.taskId,
+        nodes,
+        edges,
+        meta: {
+            createdAt: new Date().toISOString(),
+            generatedBy: opts.generatedBy ?? 'tmd plan',
+        },
+    });
+}
+export function validateExecutionPlan(plan) {
+    const issues = [];
+    const nodeIds = new Set();
+    for (const n of plan.nodes) {
+        if (nodeIds.has(n.id)) {
+            issues.push({ level: 'error', message: `Duplicate node id: ${n.id}` });
+        }
+        nodeIds.add(n.id);
+    }
+    for (const e of plan.edges) {
+        if (!nodeIds.has(e.source)) {
+            issues.push({ level: 'error', message: `Edge references missing source node: ${e.source}` });
+        }
+        if (!nodeIds.has(e.target)) {
+            issues.push({ level: 'error', message: `Edge references missing target node: ${e.target}` });
+        }
+    }
+    // Cycle detection (Kahn)
+    const indeg = new Map();
+    const adj = new Map();
+    for (const id of nodeIds) {
+        indeg.set(id, 0);
+        adj.set(id, []);
+    }
+    for (const e of plan.edges) {
+        if (!nodeIds.has(e.source) || !nodeIds.has(e.target))
+            continue;
+        adj.get(e.source).push(e.target);
+        indeg.set(e.target, (indeg.get(e.target) ?? 0) + 1);
+    }
+    const q = [];
+    for (const [id, d] of indeg.entries()) {
+        if (d === 0)
+            q.push(id);
+    }
+    let visited = 0;
+    while (q.length) {
+        const id = q.shift();
+        visited += 1;
+        for (const nxt of adj.get(id) ?? []) {
+            const nd = (indeg.get(nxt) ?? 0) - 1;
+            indeg.set(nxt, nd);
+            if (nd === 0)
+                q.push(nxt);
+        }
+    }
+    if (visited !== nodeIds.size) {
+        issues.push({ level: 'error', message: 'Dependency graph contains a cycle (not a DAG)' });
+    }
+    return issues;
+}
+//# sourceMappingURL=execution-plan.js.map

package/dist/utils/llm-plan.d.ts

@@ -0,0 +1,38 @@
+export interface LLMPlanOptions {
+    description: string;
+    projectRoot?: string | undefined;
+    agentId?: string | undefined;
+    onStage?: ((stage: string) => void) | undefined;
+}
+export interface LLMPlanResult {
+    success: boolean;
+    changeId?: string | undefined;
+    error?: string | undefined;
+    tasksCount?: number | undefined;
+    specsCount?: number | undefined;
+    hasDesign?: boolean | undefined;
+    tasks?: Array<{
+        title: string;
+        deliverable: string;
+        validation: string;
+        dependencies: number[];
+        parallelizable: boolean;
+        complexity: string;
+    }> | undefined;
+}
+/**
+ * Check if spec features are enabled for this project
+ */
+export declare function isOpenSpecProject(root?: string): boolean;
+/**
+ * Call the Rust binary to generate a proposal using LLM
+ */
+export declare function generateLLMPlan(options: LLMPlanOptions): Promise<LLMPlanResult>;
+/**
+ * Display progress indicator while generating
+ */
+export declare function showGenerationProgress(): {
+    setStage(next: string): void;
+    stop(): void;
+};
+//# sourceMappingURL=llm-plan.d.ts.map

package/dist/utils/llm-plan.js

@@ -0,0 +1,159 @@
+import { spawn } from 'child_process';
+import { join } from 'path';
+import { existsSync } from 'fs';
+import chalk from 'chalk';
+/**
+ * Check if spec features are enabled for this project
+ */
+export function isOpenSpecProject(root = '.') {
+    // Spec-enabled mode: prefer `.tmd/specs/` (new layout). For compatibility, allow legacy `openspec/specs/`.
+    const tmdSpecsDir = join(root, '.tmd', 'specs');
+    if (existsSync(tmdSpecsDir))
+        return true;
+    const legacySpecsDir = join(root, 'openspec', 'specs');
+    return existsSync(legacySpecsDir);
+}
+/**
+ * Call the Rust binary to generate a proposal using LLM
+ */
+export async function generateLLMPlan(options) {
+    const { description, projectRoot = '.', agentId = 'planner', onStage, } = options;
+    // Find the Rust binary (try release first, then debug)
+    const binaryName = 'tmd-plan-gen';
+    const releasePath = join(process.cwd(), 'target', 'release', binaryName);
+    const debugPath = join(process.cwd(), 'target', 'debug', binaryName);
+    const distPath = join(process.cwd(), 'dist', binaryName);
+    let binaryPath;
+    if (existsSync(distPath)) {
+        binaryPath = distPath;
+    }
+    else if (existsSync(releasePath)) {
+        binaryPath = releasePath;
+    }
+    else if (existsSync(debugPath)) {
+        binaryPath = debugPath;
+    }
+    else {
+        return {
+            success: false,
+            error: `Binary not found. Run 'cargo build -p tmd-plan --bin tmd-plan-gen' first.`,
+        };
+    }
+    return new Promise((resolve) => {
+        const args = [
+            description,
+            '--project-root', projectRoot,
+            '--agent-id', agentId,
+        ];
+        const child = spawn(binaryPath, args);
+        let stdout = '';
+        let stderr = '';
+        let jsonOutput = '';
+        let inJson = false;
+        child.stdout.on('data', (data) => {
+            const text = data.toString();
+            stdout += text;
+            // Stream stage updates (best-effort)
+            for (const line of text.split('\n')) {
+                if (!line.startsWith('__STAGE__ '))
+                    continue;
+                const stage = line.replace('__STAGE__ ', '').trim();
+                try {
+                    onStage?.(stage);
+                }
+                catch {
+                    // ignore callback errors
+                }
+            }
+            // Extract JSON output
+            const lines = text.split('\n');
+            for (const line of lines) {
+                if (line.includes('__JSON_START__')) {
+                    inJson = true;
+                    jsonOutput = '';
+                }
+                else if (line.includes('__JSON_END__')) {
+                    inJson = false;
+                }
+                else if (inJson) {
+                    jsonOutput += line;
+                }
+                else if (line.startsWith('__STAGE__ ')) {
+                    // handled above; don't print
+                }
+                else {
+                    // Print non-JSON output
+                    process.stdout.write(line + '\n');
+                }
+            }
+        });
+        child.stderr.on('data', (data) => {
+            stderr += data.toString();
+            process.stderr.write(data);
+        });
+        child.on('close', (code) => {
+            if (code === 0) {
+                // Parse JSON output if available
+                if (jsonOutput) {
+                    try {
+                        const result = JSON.parse(jsonOutput);
+                        resolve({
+                            success: true,
+                            changeId: result.change_id,
+                            tasksCount: result.tasks?.length || 0,
+                            specsCount: result.spec_deltas?.length || 0,
+                            hasDesign: !!result.design,
+                            tasks: Array.isArray(result.tasks) ? result.tasks : undefined,
+                        });
+                        return;
+                    }
+                    catch (e) {
+                        // JSON parse failed, but command succeeded
+                    }
+                }
+                // Fallback: extract change ID from stdout
+                const changeIdMatch = stdout.match(/Change ID: ([\w-]+)/);
+                resolve({
+                    success: true,
+                    changeId: changeIdMatch ? changeIdMatch[1] : undefined,
+                });
+            }
+            else {
+                resolve({
+                    success: false,
+                    error: stderr || `Command failed with exit code ${code}`,
+                });
+            }
+        });
+        child.on('error', (error) => {
+            resolve({
+                success: false,
+                error: `Failed to spawn binary: ${error.message}`,
+            });
+        });
+    });
+}
+/**
+ * Display progress indicator while generating
+ */
+export function showGenerationProgress() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let i = 0;
+    let stage = 'Starting...';
+    const start = Date.now();
+    const interval = setInterval(() => {
+        const elapsedMs = Date.now() - start;
+        process.stdout.write(`\r${chalk.blue(frames[i])} ${stage} ${chalk.dim(`(${(elapsedMs / 1000).toFixed(1)}s)`)}`);
+        i = (i + 1) % frames.length;
+    }, 80);
+    return {
+        setStage(next) {
+            stage = next;
+        },
+        stop() {
+            clearInterval(interval);
+            process.stdout.write('\r');
+        },
+    };
+}
+//# sourceMappingURL=llm-plan.js.map

package/dist/utils/openspec.js

@@ -50,7 +50,7 @@ export function createOpenSpecChange(description, taskId) {
 `;
     writeFileSync(join(changeDir, 'tasks.md'), tasksContent);
     // Link TMD task to OpenSpec change
-    const metadataPath = join('tmd', 'plan', taskId, 'metadata.json');
+    const metadataPath = join('.tmd', 'plan', taskId, 'metadata.json');
     if (existsSync(metadataPath)) {
         const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
         metadata['openspecChange'] = changeId;
@@ -70,7 +70,7 @@ export function linkOpenSpecChange(taskId, changeId) {
         return false;
     }
     // Link in task metadata
-    const metadataPath = join('tmd', 'plan', taskId, 'metadata.json');
+    const metadataPath = join('.tmd', 'plan', taskId, 'metadata.json');
     if (existsSync(metadataPath)) {
         const metadata = JSON.parse(readFileSync(metadataPath, 'utf-8'));
         metadata['openspecChange'] = changeId;

package/dist/utils/paths.d.ts

@@ -1,4 +1,9 @@
 export declare function getTmdDir(): string;
+export declare function getAgentsDir(): string;
+/**
+ * Ensures .tmd/ and .agents/ exist under projectRoot. Idempotent; does not overwrite.
+ */
+export declare function ensureProjectDirs(projectRoot: string): void;
 export declare function getTaskDir(phase: string, taskId: string): string;
 export declare function ensureDir(path: string): void;
 export declare function getPlanDir(taskId: string): string;

package/dist/utils/paths.js

@@ -1,9 +1,20 @@
 import { join } from 'path';
 import { existsSync, mkdirSync } from 'fs';
 const TMD_DIR = '.tmd';
+const AGENTS_DIR = '.agents';
 export function getTmdDir() {
     return TMD_DIR;
 }
+export function getAgentsDir() {
+    return AGENTS_DIR;
+}
+/**
+ * Ensures .tmd/ and .agents/ exist under projectRoot. Idempotent; does not overwrite.
+ */
+export function ensureProjectDirs(projectRoot) {
+    ensureDir(join(projectRoot, TMD_DIR));
+    ensureDir(join(projectRoot, AGENTS_DIR));
+}
 export function getTaskDir(phase, taskId) {
     return join(TMD_DIR, phase, taskId);
 }

package/dist/utils/skills.js

@@ -125,8 +125,7 @@ async function executeStepsConcurrently(steps, maxConcurrency, taskId, workingDi
         if (executing.length >= maxConcurrency) {
             const completed = await Promise.race(executing);
             results.push(completed);
-            // 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);
+            void executing.splice(executing.indexOf(promise), 1);
         }
     }
     // Wait for remaining steps

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

@@ -2,5 +2,6 @@ import type { TaskMetadata } from '../types.js';
 export type TaskStatus = 'planning' | 'doing' | 'checking' | 'acting' | 'completed';
 export declare function getTaskStatus(taskId: string): TaskStatus;
 export declare function updateTaskStatus(taskId: string, status: TaskStatus): void;
+export declare function updateTaskMetadata(taskId: string, patch: Partial<TaskMetadata>): void;
 export declare function getTaskMetadata(taskId: string): TaskMetadata;
 //# sourceMappingURL=task-status.d.ts.map

package/dist/utils/task-status.js

@@ -46,6 +46,17 @@ export function updateTaskStatus(taskId, status) {
     }
     writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
 }
+export function updateTaskMetadata(taskId, patch) {
+    const planDir = getPlanDir(taskId);
+    const metadataPath = join(planDir, 'metadata.json');
+    ensureDir(planDir);
+    const metadata = existsSync(metadataPath)
+        ? JSON.parse(readFileSync(metadataPath, 'utf-8'))
+        : {};
+    Object.assign(metadata, patch);
+    metadata.lastUpdated = new Date().toISOString();
+    writeFileSync(metadataPath, JSON.stringify(metadata, null, 2));
+}
 export function getTaskMetadata(taskId) {
     const metadataPath = join(getPlanDir(taskId), 'metadata.json');
     if (existsSync(metadataPath)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tmddev/tmd",
-  "version": "0.3.0",
+  "version": "0.3.2",
   "description": "Task Markdown Driven - A lightweight PDCA cycle management framework integrated with OpenSpec",
   "type": "module",
   "publishConfig": {
@@ -55,10 +55,9 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.12.0",
     "@vitest/ui": "^3.2.4",
-    "eslint": "^9.39.2",
+    "oxlint": "^1.41.0",
     "tsx": "^4.19.2",
     "typescript": "^5.7.3",
-    "typescript-eslint": "^8.50.1",
     "vitest": "^3.2.4"
   },
   "engines": {
@@ -66,7 +65,7 @@
     "bun": ">=1.0"
   },
   "scripts": {
-    "lint": "eslint src/",
+    "lint": "oxlint src/ build.ts",
     "build": "tsx build.ts",
     "build:native": "node scripts/build-native.mjs",
     "dev": "tsc --watch",

package/dist/utils/skillssh.d.ts

@@ -1,12 +0,0 @@
-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, skillName?: string): Promise<SkillsshResult>;
-export {};
-//# sourceMappingURL=skillssh.d.ts.map