@tmddev/tmd 0.1.0 → 0.2.0

package/dist/commands/validate.js

@@ -0,0 +1,179 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import yaml from 'js-yaml';
+import { getPlanDir, getDoDir, getCheckDir, getActDir, getSchemasDir, getTmdDir, } from '../utils/paths.js';
+import { getTaskStatus } from '../utils/task-status.js';
+function getBase() {
+    return process.cwd();
+}
+function validateTask(taskId, base, strict) {
+    const issues = [];
+    const planPath = join(base, getPlanDir(taskId), 'plan.md');
+    if (!existsSync(planPath)) {
+        issues.push({ level: 'error', path: 'plan.md', message: 'plan.md not found' });
+        return { taskId, valid: false, issues };
+    }
+    const required = ['Why', 'Goals', 'Tasks'];
+    const content = readFileSync(planPath, 'utf-8');
+    for (const h of required) {
+        if (!content.includes(`## ${h}`) && !content.includes(`##${h}`)) {
+            issues.push({ level: 'error', path: 'plan.md', message: `Missing required section: ## ${h}` });
+        }
+    }
+    const status = getTaskStatus(taskId);
+    if (status !== 'planning') {
+        const doPath = join(base, getDoDir(taskId), 'execution.md');
+        if (!existsSync(doPath)) {
+            issues.push({ level: 'warning', path: 'do/execution.md', message: 'execution.md missing for non-planning status' });
+        }
+    }
+    if (status === 'checking' || status === 'acting' || status === 'completed') {
+        const checkPath = join(base, getCheckDir(taskId), 'evaluation.md');
+        if (!existsSync(checkPath)) {
+            issues.push({ level: 'warning', path: 'check/evaluation.md', message: 'evaluation.md missing' });
+        }
+    }
+    if (status === 'acting' || status === 'completed') {
+        const actPath = join(base, getActDir(taskId), 'improvement.md');
+        if (!existsSync(actPath)) {
+            issues.push({ level: 'warning', path: 'act/improvement.md', message: 'improvement.md missing' });
+        }
+    }
+    if (strict) {
+        const tasksMatch = content.match(/##\s*Tasks[\s\S]*?(?=##|$)/i);
+        if (tasksMatch) {
+            const block = tasksMatch[0];
+            const lines = block.split('\n').filter((l) => /^\s*-\s+\[\s?[x ]?\s?]\s+.+/.test(l) || /^\s*-\s+.+/.test(l));
+            if (lines.length === 0) {
+                issues.push({ level: 'warning', path: 'plan.md', message: 'Tasks section has no checklist items' });
+            }
+        }
+    }
+    const hasError = issues.some((i) => i.level === 'error');
+    return { taskId, valid: !hasError, issues };
+}
+function validateSchema(name, base) {
+    const issues = [];
+    const schemaDir = join(base, getSchemasDir(), name);
+    const schemaPath = join(schemaDir, 'schema.yaml');
+    if (!existsSync(schemaPath)) {
+        issues.push({ level: 'error', path: 'schema.yaml', message: 'schema.yaml not found' });
+        return { name, valid: false, issues };
+    }
+    let data;
+    try {
+        data = yaml.load(readFileSync(schemaPath, 'utf-8'));
+    }
+    catch (e) {
+        issues.push({ level: 'error', path: 'schema.yaml', message: `Invalid YAML: ${e.message}` });
+        return { name, valid: false, issues };
+    }
+    if (data == null || typeof data !== 'object') {
+        issues.push({ level: 'error', path: 'schema.yaml', message: 'schema must be an object' });
+        return { name, valid: false, issues };
+    }
+    const obj = data;
+    if (!obj['name'] || typeof obj['name'] !== 'string') {
+        issues.push({ level: 'error', path: 'schema.yaml', message: 'Missing or invalid "name"' });
+    }
+    if (!obj['artifacts'] || !Array.isArray(obj['artifacts'])) {
+        issues.push({ level: 'error', path: 'schema.yaml', message: 'Missing or invalid "artifacts" array' });
+    }
+    else {
+        const templatesDir = join(schemaDir, 'templates');
+        for (const a of obj['artifacts']) {
+            const t = a.template;
+            if (t && existsSync(templatesDir)) {
+                const tPath = join(templatesDir, t);
+                if (!existsSync(tPath)) {
+                    issues.push({ level: 'warning', path: `templates/${t}`, message: `Template not found: ${t}` });
+                }
+            }
+        }
+    }
+    const hasError = issues.some((i) => i.level === 'error');
+    return { name, valid: !hasError, issues };
+}
+function gatherTaskIds(base) {
+    const planDir = join(base, getTmdDir(), 'plan');
+    if (!existsSync(planDir))
+        return [];
+    return readdirSync(planDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+}
+function gatherSchemaNames(base) {
+    const schemasDir = join(base, getSchemasDir());
+    if (!existsSync(schemasDir))
+        return [];
+    return readdirSync(schemasDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory() && existsSync(join(schemasDir, d.name, 'schema.yaml')))
+        .map((d) => d.name);
+}
+export function validateCommand(taskId, opts) {
+    const base = getBase();
+    const options = opts ?? {};
+    const { schemas: schemasArg, all, strict = false, json: asJson } = options;
+    const taskResults = [];
+    const schemaResults = [];
+    if (all || taskId !== undefined) {
+        const ids = all ? gatherTaskIds(base) : (taskId ? [taskId] : []);
+        for (const id of ids) {
+            taskResults.push(validateTask(id, base, strict));
+        }
+        if (taskId && ids.length === 0) {
+            taskResults.push({ taskId: taskId, valid: false, issues: [{ level: 'error', path: 'plan', message: 'Task not found' }] });
+        }
+    }
+    if (all || schemasArg !== undefined) {
+        const names = schemasArg !== undefined
+            ? (typeof schemasArg === 'string' && schemasArg.length > 0 ? [schemasArg] : gatherSchemaNames(base))
+            : all
+                ? gatherSchemaNames(base)
+                : [];
+        for (const n of names) {
+            schemaResults.push(validateSchema(n, base));
+        }
+        if (schemasArg && schemaResults.length === 0 && !all) {
+            schemaResults.push({
+                name: schemasArg,
+                valid: false,
+                issues: [{ level: 'error', path: 'schemas', message: `Schema not found: ${schemasArg}` }],
+            });
+        }
+    }
+    if (taskResults.length === 0 && schemaResults.length === 0) {
+        if (asJson) {
+            console.log(JSON.stringify({ valid: true, tasks: [], schemas: [], message: 'Nothing to validate' }));
+        }
+        else {
+            console.log(chalk.yellow('Nothing to validate. Use: tmd validate <task-id>, --schemas [name], or --all'));
+        }
+        return;
+    }
+    const anyInvalid = [...taskResults, ...schemaResults].some((r) => !r.valid);
+    if (asJson) {
+        console.log(JSON.stringify({ valid: !anyInvalid, tasks: taskResults, schemas: schemaResults }));
+        process.exitCode = anyInvalid ? 1 : 0;
+        return;
+    }
+    console.log(chalk.bold('\nValidation'));
+    console.log('─'.repeat(60));
+    for (const r of taskResults) {
+        const badge = r.valid ? chalk.green('✓') : chalk.red('✗');
+        console.log(`  ${badge} ${r.taskId}`);
+        for (const i of r.issues) {
+            console.log(`      ${i.level}: ${i.message}`);
+        }
+    }
+    for (const r of schemaResults) {
+        const badge = r.valid ? chalk.green('✓') : chalk.red('✗');
+        console.log(`  ${badge} schema: ${r.name}`);
+        for (const i of r.issues) {
+            console.log(`      ${i.level}: ${i.message}`);
+        }
+    }
+    process.exitCode = anyInvalid ? 1 : 0;
+}
+//# sourceMappingURL=validate.js.map

package/dist/commands/view.d.ts

@@ -0,0 +1,2 @@
+export declare function viewCommand(): void;
+//# sourceMappingURL=view.d.ts.map

package/dist/commands/view.js

@@ -0,0 +1,65 @@
+import { existsSync, readdirSync } from 'fs';
+import { join } from 'path';
+import chalk from 'chalk';
+import { getTmdDir } from '../utils/paths.js';
+import { getTaskStatus } from '../utils/task-status.js';
+import { getTaskMetadata } from '../utils/task-status.js';
+export function viewCommand() {
+    const tmdDir = getTmdDir();
+    const planDir = join(tmdDir, 'plan');
+    if (!existsSync(planDir)) {
+        console.log(chalk.bold('\nTMD Dashboard\n'));
+        console.log('═'.repeat(60));
+        console.log(chalk.dim('No tasks found. Create one with: tmd plan "description"'));
+        console.log('═'.repeat(60));
+        return;
+    }
+    const taskIds = readdirSync(planDir, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .map((d) => d.name);
+    const byStatus = {
+        planning: [],
+        doing: [],
+        checking: [],
+        acting: [],
+        completed: [],
+    };
+    for (const id of taskIds) {
+        const s = getTaskStatus(id);
+        (byStatus[s] ??= []).push(id);
+    }
+    console.log(chalk.bold('\nTMD Dashboard\n'));
+    console.log('═'.repeat(60));
+    console.log(chalk.bold('Summary'));
+    console.log('─'.repeat(60));
+    console.log(`  planning:   ${String(byStatus['planning']?.length ?? 0)}`);
+    console.log(`  doing:      ${String(byStatus['doing']?.length ?? 0)}`);
+    console.log(`  checking:   ${String(byStatus['checking']?.length ?? 0)}`);
+    console.log(`  acting:     ${String(byStatus['acting']?.length ?? 0)}`);
+    console.log(`  completed:  ${String(byStatus['completed']?.length ?? 0)}`);
+    console.log('─'.repeat(60));
+    console.log(chalk.bold('Tasks'));
+    console.log('─'.repeat(60));
+    if (taskIds.length === 0) {
+        console.log(chalk.dim('  No tasks. Create one with: tmd plan "description"'));
+    }
+    else {
+        for (const id of taskIds) {
+            const status = getTaskStatus(id);
+            const c = status === 'completed'
+                ? chalk.green
+                : status === 'acting'
+                    ? chalk.blue
+                    : status === 'checking'
+                        ? chalk.yellow
+                        : status === 'doing'
+                            ? chalk.cyan
+                            : chalk.gray;
+            const meta = getTaskMetadata(id);
+            const ext = meta.openspecChange ? ` ${chalk.dim(`[${meta.openspecChange}]`)}` : '';
+            console.log(`  ${chalk.cyan(id)} ${c(status)}${ext}`);
+        }
+    }
+    console.log('═'.repeat(60));
+}
+//# sourceMappingURL=view.js.map

package/dist/types.d.ts

@@ -34,6 +34,15 @@ export interface ListCommandOptions {
 }
 export interface SkillsCommandOptions {
     input?: string;
+    skill?: string;
+    description?: string;
+    tags?: string;
+    tag?: string[];
+    force?: boolean;
+    all?: boolean;
+    github?: boolean;
+    branch?: string;
+    path?: string;
 }
 export interface TaskMetadata {
     status?: string;
@@ -48,8 +57,9 @@ export interface SkillMetadata {
     version?: string;
     description?: string;
     tags?: string[];
-    source?: 'skillssh' | 'local';
+    source?: 'skillssh' | 'local' | 'github';
     repo?: string;
+    branch?: string;
     importedAt?: string;
     createdFrom?: string;
     interface?: SkillInterface;
@@ -76,4 +86,14 @@ export interface SkillStep {
     depends?: string[] | number[];
     [key: string]: unknown;
 }
+export interface PipelineInitOptions {
+    force?: boolean;
+}
+export interface PipelineRunOptions {
+    from?: string;
+    dryRun?: boolean;
+}
+export interface PipelineStatusOptions {
+    json?: boolean;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/utils/github.d.ts

@@ -0,0 +1,18 @@
+interface GitHubImportResult {
+    success: boolean;
+    skillName?: string;
+    skillDir?: string;
+    error?: string;
+}
+interface GitHubImportOptions {
+    skillName?: string | undefined;
+    branch?: string | undefined;
+    path?: string | undefined;
+    force?: boolean | undefined;
+}
+/**
+ * Fetches and converts a skill from a GitHub repository to TMD format
+ */
+export declare function addSkillFromGitHub(ownerRepo: string, options?: GitHubImportOptions): Promise<GitHubImportResult>;
+export {};
+//# sourceMappingURL=github.d.ts.map

package/dist/utils/github.js

@@ -0,0 +1,165 @@
+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 a GitHub repository to TMD format
+ */
+export async function addSkillFromGitHub(ownerRepo, options) {
+    // 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;
+    // Use provided skill name or derive from repo
+    const finalSkillName = options?.skillName ?? repo;
+    // Check if skill already exists
+    const skillDir = getSkillDir(finalSkillName);
+    if (existsSync(skillDir) && !options?.force) {
+        return {
+            success: false,
+            error: `Skill already exists: ${finalSkillName}. Use --force to overwrite.`
+        };
+    }
+    // Fetch skill content from GitHub
+    const skillContent = await fetchGitHubSkillContent(owner, repo, options);
+    if (!skillContent.success) {
+        return {
+            success: false,
+            error: skillContent.error ?? 'Failed to fetch skill'
+        };
+    }
+    // Create skill directory
+    const skillsDir = getSkillsDir();
+    if (!existsSync(skillsDir)) {
+        mkdirSync(skillsDir, { recursive: true });
+    }
+    // Remove existing if force is true
+    if (existsSync(skillDir) && options?.force) {
+        const { rmSync } = await import('fs');
+        rmSync(skillDir, { recursive: true });
+    }
+    mkdirSync(skillDir, { recursive: true });
+    // Convert and save skill files
+    saveGitHubSkillFiles(skillDir, finalSkillName, ownerRepo, skillContent.content ?? '', skillContent.branch ?? 'main');
+    return {
+        success: true,
+        skillName: finalSkillName,
+        skillDir
+    };
+}
+async function fetchGitHubSkillContent(owner, repo, options) {
+    const branches = options?.branch ? [options.branch] : ['main', 'master'];
+    const possiblePaths = [];
+    // If custom path is provided, use it directly
+    if (options?.path) {
+        for (const branch of branches) {
+            possiblePaths.push({
+                url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/${options.path}`,
+                branch
+            });
+        }
+    }
+    else {
+        // Build possible paths based on conventions
+        for (const branch of branches) {
+            // If skill name is provided, try skills subdirectory
+            if (options?.skillName) {
+                possiblePaths.push({ url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skills/${options.skillName}/SKILL.md`, branch }, { url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skills/${options.skillName}/skill.md`, branch }, { url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skills/${options.skillName}/README.md`, branch });
+            }
+            // Try root-level paths
+            possiblePaths.push({ url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/SKILL.md`, branch }, { url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/skill.md`, branch }, { url: `https://raw.githubusercontent.com/${owner}/${repo}/${branch}/README.md`, branch });
+        }
+    }
+    for (const { url, branch } of possiblePaths) {
+        try {
+            const response = await fetch(url);
+            if (response.ok) {
+                const content = await response.text();
+                return { success: true, content, branch };
+            }
+        }
+        catch {
+            // Continue to next URL
+        }
+    }
+    const skillHint = options?.skillName ? ` (skill: ${options.skillName})` : '';
+    const pathHint = options?.path ? ` (path: ${options.path})` : '';
+    return {
+        success: false,
+        error: `Could not find skill in ${owner}/${repo}${skillHint}${pathHint}. Check that the repository exists and is public.`
+    };
+}
+function saveGitHubSkillFiles(skillDir, skillName, ownerRepo, content, branch) {
+    // Parse frontmatter if present
+    const { frontmatter, body } = parseFrontmatter(content);
+    // 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 GitHub: ${ownerRepo}`;
+    // Create SKILL.md with frontmatter
+    const skillMd = `---
+name: ${skillNameFromFrontmatter}
+description: ${skillDescription}
+---
+
+${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 GitHub: ${ownerRepo}`;
+    const tags = Array.isArray(frontmatter['tags']) ? frontmatter['tags'] : [];
+    const metadata = {
+        name: skillNameFromFrontmatter,
+        version,
+        description,
+        tags,
+        source: 'github',
+        repo: ownerRepo,
+        branch,
+        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=github.js.map

package/dist/utils/paths.d.ts

@@ -7,4 +7,5 @@ export declare function getCheckDir(taskId: string): string;
 export declare function getActDir(taskId: string): string;
 export declare function getSkillsDir(): string;
 export declare function getSkillDir(skillName: string): string;
+export declare function getSchemasDir(): string;
 //# sourceMappingURL=paths.d.ts.map

package/dist/utils/paths.js

@@ -30,4 +30,8 @@ export function getSkillsDir() {
 export function getSkillDir(skillName) {
     return join(getSkillsDir(), skillName);
 }
+const SCHEMAS_DIR = 'schemas';
+export function getSchemasDir() {
+    return SCHEMAS_DIR;
+}
 //# sourceMappingURL=paths.js.map

package/dist/utils/pipeline-config.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Pipeline configuration schema and loader
+ */
+export interface PhaseSuccessCriteria {
+    minTasksCompleted?: string | number;
+    allowUnmetGoals?: boolean;
+    allowPartialGoals?: boolean;
+}
+export interface PhaseConfig {
+    auto: boolean;
+    parallel?: boolean;
+    maxConcurrency?: number;
+    analyze?: boolean;
+    recommend?: boolean;
+    standardize?: boolean;
+    carryForward?: boolean;
+    completeOnSuccess?: boolean;
+    successCriteria?: PhaseSuccessCriteria;
+}
+export interface PipelineConfig {
+    version: string;
+    phases: {
+        do: PhaseConfig;
+        check: PhaseConfig;
+        act: PhaseConfig;
+    };
+}
+export declare const DEFAULT_PIPELINE_CONFIG: PipelineConfig;
+export declare function getPipelineConfigPath(taskId: string): string;
+export declare function loadPipelineConfig(taskId: string): PipelineConfig | null;
+export declare function savePipelineConfig(taskId: string, config: PipelineConfig): void;
+export declare function generatePipelineConfigTemplate(): string;
+export declare function parseSuccessCriteria(criteria: PhaseSuccessCriteria | undefined, totalTasks: number, completedTasks: number): {
+    passed: boolean;
+    reason?: string;
+};
+//# sourceMappingURL=pipeline-config.d.ts.map

package/dist/utils/pipeline-config.js

@@ -0,0 +1,117 @@
+/**
+ * Pipeline configuration schema and loader
+ */
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import yaml from 'js-yaml';
+import { getPlanDir } from './paths.js';
+export const DEFAULT_PIPELINE_CONFIG = {
+    version: '1.0',
+    phases: {
+        do: {
+            auto: true,
+            parallel: false,
+            maxConcurrency: 4,
+            successCriteria: {
+                minTasksCompleted: '100%'
+            }
+        },
+        check: {
+            auto: true,
+            analyze: true,
+            recommend: true,
+            successCriteria: {
+                allowPartialGoals: true
+            }
+        },
+        act: {
+            auto: true,
+            standardize: true,
+            carryForward: true,
+            completeOnSuccess: true
+        }
+    }
+};
+export function getPipelineConfigPath(taskId) {
+    return join(getPlanDir(taskId), 'pipeline.yaml');
+}
+export function loadPipelineConfig(taskId) {
+    const configPath = getPipelineConfigPath(taskId);
+    if (!existsSync(configPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const config = yaml.load(content);
+        // Merge with defaults to ensure all fields exist
+        return {
+            ...DEFAULT_PIPELINE_CONFIG,
+            ...config,
+            phases: {
+                do: { ...DEFAULT_PIPELINE_CONFIG.phases.do, ...config.phases.do },
+                check: { ...DEFAULT_PIPELINE_CONFIG.phases.check, ...config.phases.check },
+                act: { ...DEFAULT_PIPELINE_CONFIG.phases.act, ...config.phases.act }
+            }
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function savePipelineConfig(taskId, config) {
+    const configPath = getPipelineConfigPath(taskId);
+    const content = yaml.dump(config, { indent: 2, lineWidth: 120 });
+    writeFileSync(configPath, content);
+}
+export function generatePipelineConfigTemplate() {
+    return `# 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
+`;
+}
+export function parseSuccessCriteria(criteria, totalTasks, completedTasks) {
+    if (!criteria) {
+        return { passed: true };
+    }
+    if (criteria.minTasksCompleted !== undefined) {
+        const minRequired = typeof criteria.minTasksCompleted === 'string'
+            ? criteria.minTasksCompleted.endsWith('%')
+                ? Math.ceil((parseFloat(criteria.minTasksCompleted) / 100) * totalTasks)
+                : parseInt(criteria.minTasksCompleted, 10)
+            : criteria.minTasksCompleted;
+        if (completedTasks < minRequired) {
+            return {
+                passed: false,
+                reason: `Only ${String(completedTasks)}/${String(totalTasks)} tasks completed (required: ${String(criteria.minTasksCompleted)})`
+            };
+        }
+    }
+    return { passed: true };
+}
+//# sourceMappingURL=pipeline-config.js.map