icopilot 2.2.0

package/dist/workflows/builtins.js

@@ -0,0 +1,128 @@
+import { stringify } from 'yaml';
+export const BUILTIN_WORKFLOWS = [
+    {
+        name: 'review-and-commit',
+        description: 'Inspect the working tree, summarize changes, and prepare a commit message.',
+        triggers: [{ type: 'manual', config: {} }],
+        steps: [
+            {
+                id: 'git-status',
+                name: 'Capture git status',
+                action: 'shell',
+                params: { command: 'git --no-pager status --short' },
+                onFail: 'stop',
+            },
+            {
+                id: 'diff-summary',
+                name: 'Capture diff summary',
+                action: 'shell',
+                params: { command: 'git --no-pager diff --stat' },
+                onFail: 'continue',
+            },
+            {
+                id: 'commit-prompt',
+                name: 'Draft commit guidance',
+                action: 'prompt',
+                params: {
+                    prompt: 'Review this status and diff summary, then draft a conventional commit message:\n\nStatus:\n${steps.git-status.output}\n\nDiff:\n${steps.diff-summary.output}',
+                },
+            },
+        ],
+    },
+    {
+        name: 'test-fix-loop',
+        description: 'Run tests, summarize failures, and iterate through follow-up prompts.',
+        triggers: [{ type: 'manual', config: {} }],
+        steps: [
+            {
+                id: 'run-tests',
+                name: 'Run repository tests',
+                action: 'shell',
+                params: { command: 'npm test -- --runInBand', retries: 1 },
+                onFail: 'continue',
+            },
+            {
+                id: 'failure-summary',
+                name: 'Summarize failures',
+                action: 'prompt',
+                params: {
+                    prompt: 'Summarize the latest test run and propose the smallest fix:\n\n${steps.run-tests.output}',
+                },
+            },
+            {
+                id: 'follow-up-loop',
+                name: 'Generate retry prompts',
+                action: 'loop',
+                params: {
+                    items: ['re-run targeted tests', 'verify typecheck', 'prepare regression summary'],
+                    steps: [
+                        {
+                            id: 'loop-prompt',
+                            name: 'Draft a follow-up action',
+                            action: 'prompt',
+                            params: {
+                                prompt: 'Next action ${loop.index}: ${loop.item}\nLatest output:\n${steps.run-tests.output}',
+                            },
+                        },
+                    ],
+                },
+            },
+        ],
+    },
+    {
+        name: 'release-prep',
+        description: 'Collect the core checks needed before shipping a release.',
+        triggers: [
+            { type: 'manual', config: {} },
+            { type: 'schedule', config: { cron: '0 9 * * 1-5' } },
+        ],
+        steps: [
+            {
+                id: 'typecheck',
+                name: 'Run typecheck',
+                action: 'shell',
+                params: { command: 'npm run typecheck' },
+                onFail: 'continue',
+            },
+            {
+                id: 'tests',
+                name: 'Run tests',
+                action: 'shell',
+                params: { command: 'npm test' },
+                onFail: 'continue',
+            },
+            {
+                id: 'release-notes',
+                name: 'Draft release checklist',
+                action: 'prompt',
+                params: {
+                    prompt: 'Prepare a release checklist using the latest typecheck and test output.\n\nTypecheck:\n${steps.typecheck.output}\n\nTests:\n${steps.tests.output}',
+                },
+            },
+        ],
+    },
+];
+export function getBuiltinWorkflow(name) {
+    return BUILTIN_WORKFLOWS.find((workflow) => workflow.name === name);
+}
+export function renderWorkflowYaml(workflow) {
+    return `${stringify(workflow).trimEnd()}\n`;
+}
+export function createWorkflowTemplate(name) {
+    return {
+        name,
+        description: `Describe what the ${name} workflow should do.`,
+        triggers: [{ type: 'manual', config: {} }],
+        steps: [
+            {
+                id: 'first-step',
+                name: 'First step',
+                action: 'prompt',
+                params: {
+                    prompt: `Workflow ${name} is ready. Replace this prompt with real steps.`,
+                },
+                onFail: 'stop',
+            },
+        ],
+    };
+}

package/dist/workflows/engine.js

@@ -0,0 +1,496 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { config } from '../config.js';
+import { parse } from 'yaml';
+export class WorkflowEngine {
+    cwd;
+    execution;
+    constructor(opts = {}) {
+        this.cwd = path.resolve(opts.cwd ?? config.cwd);
+        this.execution = this.createExecutionState();
+    }
+    loadWorkflows(dir) {
+        const workflowDir = this.resolveWorkflowDir(dir);
+        if (!fs.existsSync(workflowDir) || !fs.statSync(workflowDir).isDirectory()) {
+            return [];
+        }
+        return fs
+            .readdirSync(workflowDir)
+            .filter((entry) => entry.endsWith('.yaml') || entry.endsWith('.yml'))
+            .sort((a, b) => a.localeCompare(b))
+            .map((entry) => {
+            const filePath = path.join(workflowDir, entry);
+            const raw = fs.readFileSync(filePath, 'utf8');
+            let parsed;
+            try {
+                parsed = parse(raw);
+            }
+            catch (error) {
+                throw new Error(`Failed to parse workflow ${entry}: ${error?.message || String(error)}`);
+            }
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+                throw new Error(`Workflow ${entry} must contain a YAML object`);
+            }
+            return parsed;
+        });
+    }
+    async run(workflow, context = {}) {
+        const startedAt = Date.now();
+        const validationErrors = this.validateWorkflow(workflow);
+        if (validationErrors.length > 0) {
+            return {
+                success: false,
+                duration: Date.now() - startedAt,
+                steps: validationErrors.map((error, index) => ({
+                    stepId: `validation-${index + 1}`,
+                    success: false,
+                    error: `${error.path}: ${error.message}`,
+                    duration: 0,
+                })),
+            };
+        }
+        this.execution = this.createExecutionState(context, workflow);
+        const steps = [];
+        for (const step of workflow.steps) {
+            const result = await this.runStep(step);
+            steps.push(result);
+            this.execution.prev = result;
+            this.execution.steps[step.id] = result;
+            if (!result.success && (step.onFail ?? 'stop') === 'stop') {
+                break;
+            }
+        }
+        return {
+            success: steps.length === workflow.steps.length && steps.every((step) => step.success),
+            steps,
+            duration: Date.now() - startedAt,
+        };
+    }
+    async runStep(step) {
+        const startedAt = Date.now();
+        const retryAttempts = step.onFail === 'retry' ? this.normalizeRetryCount(step.params?.retries) : 0;
+        for (let attempt = 0;; attempt += 1) {
+            try {
+                const result = await this.executeStep(step);
+                return { ...result, duration: Date.now() - startedAt };
+            }
+            catch (error) {
+                const failure = {
+                    stepId: step.id,
+                    success: false,
+                    error: error?.message || String(error),
+                    duration: Date.now() - startedAt,
+                };
+                if (attempt >= retryAttempts) {
+                    return failure;
+                }
+            }
+        }
+    }
+    validateWorkflow(def) {
+        const errors = [];
+        if (!def || typeof def !== 'object' || Array.isArray(def)) {
+            return [{ path: 'workflow', message: 'Workflow definition must be an object' }];
+        }
+        if (!this.isNonEmptyString(def.name)) {
+            errors.push({ path: 'name', message: 'Workflow name is required' });
+        }
+        if (!this.isNonEmptyString(def.description)) {
+            errors.push({ path: 'description', message: 'Workflow description is required' });
+        }
+        if (!Array.isArray(def.steps) || def.steps.length === 0) {
+            errors.push({ path: 'steps', message: 'Workflow must include at least one step' });
+        }
+        const seenStepIds = new Set();
+        for (const [index, step] of (def.steps ?? []).entries()) {
+            const stepPath = `steps[${index}]`;
+            if (!step || typeof step !== 'object' || Array.isArray(step)) {
+                errors.push({ path: stepPath, message: 'Step must be an object' });
+                continue;
+            }
+            if (!this.isNonEmptyString(step.id)) {
+                errors.push({ path: `${stepPath}.id`, message: 'Step id is required' });
+            }
+            else if (seenStepIds.has(step.id)) {
+                errors.push({ path: `${stepPath}.id`, message: `Duplicate step id "${step.id}"` });
+            }
+            else {
+                seenStepIds.add(step.id);
+            }
+            if (!this.isNonEmptyString(step.name)) {
+                errors.push({ path: `${stepPath}.name`, message: 'Step name is required' });
+            }
+            if (!['command', 'prompt', 'shell', 'condition', 'loop'].includes(step.action)) {
+                errors.push({
+                    path: `${stepPath}.action`,
+                    message: `Unsupported step action "${step.action}"`,
+                });
+            }
+            if (!step.params || typeof step.params !== 'object' || Array.isArray(step.params)) {
+                errors.push({ path: `${stepPath}.params`, message: 'Step params must be an object' });
+                continue;
+            }
+            switch (step.action) {
+                case 'command':
+                    if (!this.isNonEmptyString(step.params.command)) {
+                        errors.push({
+                            path: `${stepPath}.params.command`,
+                            message: 'command step requires params.command',
+                        });
+                    }
+                    if (step.params.args !== undefined && !Array.isArray(step.params.args)) {
+                        errors.push({
+                            path: `${stepPath}.params.args`,
+                            message: 'command step params.args must be an array',
+                        });
+                    }
+                    break;
+                case 'prompt':
+                    if (!this.isNonEmptyString(step.params.prompt) &&
+                        !this.isNonEmptyString(step.params.template)) {
+                        errors.push({
+                            path: `${stepPath}.params.prompt`,
+                            message: 'prompt step requires params.prompt or params.template',
+                        });
+                    }
+                    break;
+                case 'shell':
+                    if (!this.isNonEmptyString(step.params.command) &&
+                        !this.isNonEmptyString(step.params.script)) {
+                        errors.push({
+                            path: `${stepPath}.params.command`,
+                            message: 'shell step requires params.command or params.script',
+                        });
+                    }
+                    break;
+                case 'condition':
+                    if (step.params.if === undefined &&
+                        step.params.expression === undefined &&
+                        step.params.value === undefined) {
+                        errors.push({
+                            path: `${stepPath}.params.if`,
+                            message: 'condition step requires params.if, params.expression, or params.value',
+                        });
+                    }
+                    if (step.params.then !== undefined && !this.isStepArray(step.params.then)) {
+                        errors.push({
+                            path: `${stepPath}.params.then`,
+                            message: 'condition step params.then must be a step array',
+                        });
+                    }
+                    if (step.params.else !== undefined && !this.isStepArray(step.params.else)) {
+                        errors.push({
+                            path: `${stepPath}.params.else`,
+                            message: 'condition step params.else must be a step array',
+                        });
+                    }
+                    break;
+                case 'loop':
+                    if (step.params.items === undefined) {
+                        errors.push({
+                            path: `${stepPath}.params.items`,
+                            message: 'loop step requires params.items',
+                        });
+                    }
+                    if (!this.isStepArray(step.params.steps)) {
+                        errors.push({
+                            path: `${stepPath}.params.steps`,
+                            message: 'loop step requires params.steps as an array',
+                        });
+                    }
+                    break;
+            }
+        }
+        for (const [index, trigger] of (def.triggers ?? []).entries()) {
+            const triggerPath = `triggers[${index}]`;
+            if (!trigger || typeof trigger !== 'object' || Array.isArray(trigger)) {
+                errors.push({ path: triggerPath, message: 'Trigger must be an object' });
+                continue;
+            }
+            if (!['manual', 'file-change', 'schedule', 'hook'].includes(trigger.type)) {
+                errors.push({
+                    path: `${triggerPath}.type`,
+                    message: `Unsupported trigger type "${trigger.type}"`,
+                });
+            }
+            if (!trigger.config || typeof trigger.config !== 'object' || Array.isArray(trigger.config)) {
+                errors.push({ path: `${triggerPath}.config`, message: 'Trigger config must be an object' });
+            }
+        }
+        return errors;
+    }
+    async executeStep(step) {
+        switch (step.action) {
+            case 'command':
+                return this.executeCommandStep(step, this.interpolate(step.params));
+            case 'prompt':
+                return {
+                    stepId: step.id,
+                    success: true,
+                    output: String(this.interpolate(step.params.prompt ?? step.params.template ?? '')),
+                };
+            case 'shell':
+                return this.executeShellStep(step, this.interpolate(step.params));
+            case 'condition':
+                return this.executeConditionStep(step, step.params);
+            case 'loop':
+                return this.executeLoopStep(step, step.params);
+            default:
+                throw new Error(`Unsupported workflow action: ${step.action}`);
+        }
+    }
+    async executeCommandStep(step, params) {
+        const command = String(params.command);
+        const args = Array.isArray(params.args) ? params.args.map((arg) => String(arg)) : [];
+        const cwd = this.resolveCwd(params.cwd);
+        const result = await this.runProcess(command, args, cwd, false);
+        return {
+            stepId: step.id,
+            success: result.exitCode === 0,
+            output: result.stdout,
+            error: result.exitCode === 0
+                ? undefined
+                : result.stderr || `Command exited with code ${result.exitCode}`,
+        };
+    }
+    async executeShellStep(step, params) {
+        const shellCommand = String(params.command ?? params.script ?? '');
+        const cwd = this.resolveCwd(params.cwd);
+        const shell = process.platform === 'win32' ? 'powershell.exe' : 'bash';
+        const shellArgs = process.platform === 'win32'
+            ? ['-NoProfile', '-Command', shellCommand]
+            : ['-lc', shellCommand];
+        const result = await this.runProcess(shell, shellArgs, cwd, false);
+        return {
+            stepId: step.id,
+            success: result.exitCode === 0,
+            output: result.stdout,
+            error: result.exitCode === 0
+                ? undefined
+                : result.stderr || `Shell exited with code ${result.exitCode}`,
+        };
+    }
+    async executeConditionStep(step, params) {
+        const rawCondition = this.interpolate(params.if ?? params.expression ?? params.value);
+        const passed = this.toBoolean(rawCondition);
+        const branchSteps = this.normalizeNestedSteps(passed ? params.then : params.else);
+        const branchResults = await this.executeNestedSteps(branchSteps);
+        const branchSucceeded = branchResults.every((result) => result.success);
+        return {
+            stepId: step.id,
+            success: branchSucceeded,
+            output: {
+                passed,
+                branch: passed ? 'then' : 'else',
+                steps: branchResults,
+            },
+        };
+    }
+    async executeLoopStep(step, params) {
+        const items = this.normalizeLoopItems(this.interpolate(params.items));
+        const nestedSteps = this.normalizeNestedSteps(params.steps);
+        const previousLoop = this.execution.loop;
+        const loopResults = [];
+        let success = true;
+        try {
+            for (const [index, item] of items.entries()) {
+                this.execution.loop = { index, item, items };
+                const results = await this.executeNestedSteps(nestedSteps);
+                loopResults.push({ index, item, steps: results });
+                if (!results.every((result) => result.success)) {
+                    success = false;
+                    break;
+                }
+            }
+        }
+        finally {
+            this.execution.loop = previousLoop;
+        }
+        return {
+            stepId: step.id,
+            success,
+            output: loopResults,
+        };
+    }
+    async executeNestedSteps(steps) {
+        const results = [];
+        for (const step of steps) {
+            const result = await this.runStep(step);
+            results.push(result);
+            this.execution.prev = result;
+            this.execution.steps[step.id] = result;
+            if (!result.success && (step.onFail ?? 'stop') === 'stop') {
+                break;
+            }
+        }
+        return results;
+    }
+    interpolate(value) {
+        if (typeof value === 'string') {
+            return this.interpolateString(value);
+        }
+        if (Array.isArray(value)) {
+            return value.map((item) => this.interpolate(item));
+        }
+        if (value && typeof value === 'object') {
+            return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, this.interpolate(item)]));
+        }
+        return value;
+    }
+    interpolateString(template) {
+        const exactMatch = template.match(/^\$\{([^}]+)\}$/);
+        if (exactMatch) {
+            return this.resolveVariable(exactMatch[1].trim());
+        }
+        return template.replace(/\$\{([^}]+)\}/g, (_match, expression) => this.renderInterpolatedValue(this.resolveVariable(String(expression).trim())));
+    }
+    resolveVariable(expression) {
+        const normalized = expression.replace(/\[(\d+)\]/g, '.$1');
+        const segments = normalized.split('.').filter(Boolean);
+        if (segments.length === 0)
+            return undefined;
+        const [root, ...rest] = segments;
+        let current;
+        switch (root) {
+            case 'prev':
+                current = this.execution.prev;
+                break;
+            case 'context':
+                current = this.execution.context;
+                break;
+            case 'steps':
+                current = this.execution.steps;
+                break;
+            case 'workflow':
+                current = this.execution.workflow;
+                break;
+            case 'loop':
+                current = this.execution.loop;
+                break;
+            default:
+                current =
+                    this.execution.context[root] !== undefined
+                        ? this.execution.context[root]
+                        : this.execution.steps[root];
+                break;
+        }
+        for (const segment of rest) {
+            if (current == null)
+                return undefined;
+            current = current[segment];
+        }
+        return current;
+    }
+    renderInterpolatedValue(value) {
+        if (value == null)
+            return '';
+        if (typeof value === 'string')
+            return value;
+        return JSON.stringify(value);
+    }
+    toBoolean(value) {
+        if (typeof value === 'boolean')
+            return value;
+        if (typeof value === 'number')
+            return value !== 0;
+        if (typeof value === 'string') {
+            const normalized = value.trim().toLowerCase();
+            if (normalized === '' ||
+                normalized === 'false' ||
+                normalized === '0' ||
+                normalized === 'no') {
+                return false;
+            }
+            return true;
+        }
+        if (Array.isArray(value))
+            return value.length > 0;
+        return Boolean(value);
+    }
+    normalizeLoopItems(value) {
+        if (Array.isArray(value))
+            return value;
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+            return Array.from({ length: Math.floor(value) }, (_item, index) => index);
+        }
+        if (value && typeof value === 'object')
+            return Object.values(value);
+        return [];
+    }
+    normalizeNestedSteps(value) {
+        if (!Array.isArray(value))
+            return [];
+        return value;
+    }
+    resolveWorkflowDir(inputDir) {
+        const absolute = path.resolve(inputDir);
+        const directDir = absolute;
+        const nestedDir = path.join(absolute, '.icopilot', 'workflows');
+        if (fs.existsSync(directDir) && path.basename(directDir) === 'workflows') {
+            return directDir;
+        }
+        if (fs.existsSync(nestedDir)) {
+            return nestedDir;
+        }
+        return directDir;
+    }
+    resolveCwd(candidate) {
+        const baseDir = this.execution.context.cwd ?? this.cwd;
+        if (typeof candidate !== 'string' || candidate.trim() === '') {
+            return path.resolve(baseDir);
+        }
+        return path.resolve(baseDir, candidate);
+    }
+    normalizeRetryCount(value) {
+        if (typeof value === 'number' && Number.isFinite(value) && value >= 0) {
+            return Math.floor(value);
+        }
+        return 1;
+    }
+    async runProcess(command, args, cwd, useShell) {
+        return new Promise((resolve, reject) => {
+            const child = spawn(command, args, {
+                cwd,
+                shell: useShell && process.platform === 'win32',
+                stdio: ['ignore', 'pipe', 'pipe'],
+            });
+            let stdout = '';
+            let stderr = '';
+            child.stdout.on('data', (chunk) => {
+                stdout += chunk.toString();
+            });
+            child.stderr.on('data', (chunk) => {
+                stderr += chunk.toString();
+            });
+            child.on('error', (error) => {
+                reject(error);
+            });
+            child.on('close', (exitCode) => {
+                resolve({
+                    exitCode,
+                    stdout: stdout.trim(),
+                    stderr: stderr.trim(),
+                });
+            });
+        });
+    }
+    createExecutionState(context = {}, workflow) {
+        return {
+            context: {
+                ...(context && typeof context === 'object' ? context : {}),
+                cwd: context && typeof context === 'object' && typeof context.cwd === 'string'
+                    ? context.cwd
+                    : this.cwd,
+            },
+            steps: {},
+            workflow,
+        };
+    }
+    isNonEmptyString(value) {
+        return typeof value === 'string' && value.trim().length > 0;
+    }
+    isStepArray(value) {
+        return Array.isArray(value);
+    }
+}