singleton-pipeline 0.4.0-beta.13 → 0.4.0-beta.14

package/dist/packages/cli/src/executor/replay-loop.js

@@ -0,0 +1,120 @@
+import { buildUserMessage, resolveDebugInputOverridesFromEdit, } from './inputs.js';
+import { debugToken, editDebugInputs, formatDebugList, logDebugPromptPreview, pushDebugEvent, } from './debug-loop.js';
+export async function prepareReplayAttempt({ attempt, finalAttempt, stepSnapshot, snapshotManager, stepOriginalPaths, stepRegistrySnapshot, registry, replayInputs, replayInputOverride, step, debugEvents, inputDefs, timeline, shell, outputNames, workspaceInfoForAttempt, systemPrompt, securityPolicy, debugInputOverrides, currentSnapshot, stats, provider, model, runnerAgent, permissionMode, totalAttemptSeconds, totalAttemptTurns, totalAttemptCost, timelineIndex, failStep, }) {
+    attempt += 1;
+    if (finalAttempt?.stepChanges?.length || finalAttempt?.stepWrites?.length) {
+        timeline.logMuted(`${debugToken.policy('Replay is restoring project files touched by the previous attempt. Previous run artifacts are kept under their attempt folder.')}`);
+        timeline.logMuted(`${debugToken.key('pending restore')} ${formatDebugList((finalAttempt.stepChanges || []).map((entry) => entry.relPath))}`);
+        timeline.logMuted(`${debugToken.key('previous artifacts')} ${formatDebugList((finalAttempt.stepWrites || []).map((entry) => entry.relPath))}`);
+    }
+    if (stepSnapshot && finalAttempt?.stepChanges?.length) {
+        try {
+            const result = await snapshotManager.restore({
+                snapshot: stepSnapshot,
+                originalPaths: stepOriginalPaths,
+                changes: finalAttempt.stepChanges,
+            });
+            timeline.logMuted(`${debugToken.key('restore result')} ` +
+                `${debugToken.key('restored')} ${formatDebugList(result.restored)} ` +
+                `${debugToken.muted('·')} ${debugToken.key('removed')} ${formatDebugList(result.removed)} ` +
+                `${debugToken.muted('·')} ${debugToken.key('skipped')} ${formatDebugList(result.skipped)}`);
+            if (result.skipped.length) {
+                timeline.logMuted(`${debugToken.policy('Could not restore (filtered out of snapshot):')} ${formatDebugList(result.skipped)}`);
+                stats.push({
+                    agent: step.agent,
+                    provider,
+                    model: model || '—',
+                    runnerAgent: runnerAgent || '—',
+                    securityProfile: securityPolicy.profile,
+                    permissionMode: permissionMode || '—',
+                    status: 'failed',
+                    seconds: totalAttemptSeconds,
+                    turns: totalAttemptTurns,
+                    cost: totalAttemptCost,
+                    attempts: attempt,
+                });
+                failStep(timeline, timelineIndex, 'replay restore incomplete', `Replay restore incomplete before step "${step.agent}" attempt ${attempt}. These changed files were excluded from the snapshot:\n- ${result.skipped.join('\n- ')}`);
+            }
+            currentSnapshot = await snapshotManager.captureState();
+        }
+        catch (err) {
+            stats.push({
+                agent: step.agent,
+                provider,
+                model: model || '—',
+                runnerAgent: runnerAgent || '—',
+                securityProfile: securityPolicy.profile,
+                permissionMode: permissionMode || '—',
+                status: 'failed',
+                seconds: totalAttemptSeconds,
+                turns: totalAttemptTurns,
+                cost: totalAttemptCost,
+                attempts: attempt,
+            });
+            failStep(timeline, timelineIndex, 'replay restore failed', `Replay restore failed before step "${step.agent}" attempt ${attempt}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    for (const [key, previousValue] of stepRegistrySnapshot) {
+        if (previousValue === undefined)
+            delete registry[key];
+        else
+            registry[key] = previousValue;
+    }
+    const editedInputs = new Set();
+    const replayBaseInputs = replayInputs;
+    if (replayInputOverride) {
+        const nextInputs = { ...replayInputs };
+        for (const [name, value] of Object.entries(replayInputOverride)) {
+            if (Object.prototype.hasOwnProperty.call(nextInputs, name)) {
+                nextInputs[name] = value;
+                editedInputs.add(name);
+            }
+        }
+        replayInputs = nextInputs;
+        replayInputOverride = null;
+    }
+    else {
+        replayInputs = await editDebugInputs({
+            resolvedInputs: replayInputs,
+            shell,
+            timeline,
+            step,
+            debugEvents,
+            editedInputs,
+        });
+    }
+    const runtimeOverrides = resolveDebugInputOverridesFromEdit(step, replayBaseInputs, replayInputs, inputDefs);
+    for (const [id, value] of Object.entries(runtimeOverrides)) {
+        debugInputOverrides[id] = value;
+    }
+    if (Object.keys(runtimeOverrides).length) {
+        pushDebugEvent(debugEvents, {
+            step: step.agent,
+            phase: 'post-step',
+            action: 'set-runtime-input-overrides',
+            inputIds: Object.keys(runtimeOverrides),
+            attempt,
+        });
+    }
+    if (editedInputs.size) {
+        logDebugPromptPreview({
+            systemPrompt,
+            userMessage: buildUserMessage(replayInputs, outputNames, workspaceInfoForAttempt(attempt), securityPolicy),
+            timeline,
+            editedInputs,
+        });
+    }
+    pushDebugEvent(debugEvents, {
+        step: step.agent,
+        phase: 'post-step',
+        action: 'replay-start',
+        attempt,
+        editedInputs: [...editedInputs],
+    });
+    return {
+        attempt,
+        replayInputs,
+        replayInputOverride,
+        currentSnapshot,
+    };
+}

package/dist/packages/cli/src/executor/run-report.js

@@ -0,0 +1,209 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { G, S } from '../shell.js';
+export const LATEST_RUN_ID_FILE = 'latest-run-id';
+function visibleLength(value) {
+    return String(value || '').replace(/\{[^}]+\}/g, '').length;
+}
+function padVisible(value, width, align = 'left') {
+    const str = String(value ?? '');
+    const pad = Math.max(0, width - visibleLength(str));
+    return align === 'right' ? `${' '.repeat(pad)}${str}` : `${str}${' '.repeat(pad)}`;
+}
+function formatSeconds(value) {
+    return `${Number(value || 0).toFixed(1)}s`;
+}
+function formatCost(value) {
+    const cost = Number(value || 0);
+    return cost > 0 ? `$${cost.toFixed(4)}` : '-';
+}
+function displayValue(value) {
+    return !value || value === '—' ? '-' : String(value);
+}
+// Status -> color. Only the Status cell is coloured; the rest of the row stays white
+// so the outcome is scannable without being noisy.
+function statusColor(status) {
+    if (status === 'done')
+        return S.success;
+    if (status === 'failed')
+        return S.error;
+    if (status === 'dry-run')
+        return S.warning;
+    if (status === 'skipped')
+        return S.muted;
+    return S.text;
+}
+// Section header in the debug-loop style: blank lines + `─── title ───` centered, colored accent.
+function sectionHeader(title) {
+    const width = 72;
+    const text = ` ${title} `;
+    const left = Math.max(0, Math.floor((width - text.length) / 2));
+    const right = Math.max(0, width - text.length - left);
+    return [
+        '',
+        '',
+        `{${S.subtle}-fg}${G.hline.repeat(left)}{/}{${S.accent}-fg}{bold}${text}{/}{${S.subtle}-fg}${G.hline.repeat(right)}{/}`,
+        '',
+    ];
+}
+export function renderRunSummary({ stats, fileWrites, dryRun, runDir, cwd, runStatus = null, }) {
+    const totalSeconds = stats.reduce((sum, stat) => sum + (stat.seconds || 0), 0);
+    const totalCost = stats.reduce((sum, stat) => sum + (stat.cost || 0), 0);
+    // Compact 6-column table: #, agent, model, status (colored), time, cost.
+    // Provider/Policy/Attempts/Turns are dropped - they're available in run-manifest.json.
+    const rows = stats.map((stat, index) => ({
+        step: String(index + 1),
+        agent: stat.agent,
+        model: displayValue(stat.model),
+        status: stat.status,
+        time: stat.status === 'dry-run' || stat.status === 'skipped' ? '-' : formatSeconds(stat.seconds),
+        cost: formatCost(stat.cost),
+    }));
+    const finalStatus = runStatus || (dryRun ? 'dry-run' : 'done');
+    const totalRow = {
+        step: '',
+        agent: 'TOTAL',
+        model: '-',
+        status: finalStatus,
+        time: formatSeconds(totalSeconds),
+        cost: formatCost(totalCost),
+    };
+    const allRows = [...rows, totalRow];
+    const widths = {
+        step: Math.max(1, ...allRows.map((row) => visibleLength(row.step))),
+        agent: Math.max(5, ...allRows.map((row) => visibleLength(row.agent))),
+        model: Math.max(5, ...allRows.map((row) => visibleLength(row.model))),
+        status: Math.max(6, ...allRows.map((row) => visibleLength(row.status))),
+        time: Math.max(4, ...allRows.map((row) => visibleLength(row.time))),
+        cost: Math.max(4, ...allRows.map((row) => visibleLength(row.cost))),
+    };
+    const hr = [
+        G.hline.repeat(widths.step + 2),
+        G.hline.repeat(widths.agent + 2),
+        G.hline.repeat(widths.model + 2),
+        G.hline.repeat(widths.status + 2),
+        G.hline.repeat(widths.time + 2),
+        G.hline.repeat(widths.cost + 2),
+    ].join(`{${S.subtle}-fg}${G.cross}{/}`);
+    // Bold each cell individually because `{/}` from the separator would reset a row-level bold.
+    function row(rowData, { bold = false, colorStatus = false } = {}) {
+        const b = bold ? '{bold}' : '';
+        const bClose = bold ? '{/}' : '';
+        const statusPadded = padVisible(rowData.status, widths.status);
+        const statusCell = colorStatus
+            ? `{${statusColor(rowData.status)}-fg}${b}${statusPadded}${bClose}{/}`
+            : `${b}${statusPadded}${bClose}`;
+        return [
+            ` ${b}${padVisible(rowData.step, widths.step, 'right')}${bClose} `,
+            ` ${b}${padVisible(rowData.agent, widths.agent)}${bClose} `,
+            ` ${b}${padVisible(rowData.model, widths.model)}${bClose} `,
+            ` ${statusCell} `,
+            ` ${b}${padVisible(rowData.time, widths.time, 'right')}${bClose} `,
+            ` ${b}${padVisible(rowData.cost, widths.cost, 'right')}${bClose} `,
+        ].join(`{${S.subtle}-fg}${G.vline}{/}`);
+    }
+    const lines = [
+        ...sectionHeader('Run summary'),
+        row({ step: '#', agent: 'Agent', model: 'Model', status: 'Status', time: 'Time', cost: 'Cost' }, { bold: true }),
+        `{${S.subtle}-fg}${hr}{/}`,
+        ...rows.map((item) => row(item, { colorStatus: true })),
+        `{${S.subtle}-fg}${hr}{/}`,
+        row(totalRow, { bold: true, colorStatus: true }),
+        '',
+    ];
+    if (runDir) {
+        lines.push(`  {${S.muted}-fg}Run{/}        {${S.keyword}-fg}${path.relative(cwd, runDir)}{/}`);
+    }
+    if (fileWrites.length) {
+        lines.push(`  {${S.muted}-fg}Generated{/}  {${S.keyword}-fg}${fileWrites[0]}{/}`);
+        for (const file of fileWrites.slice(1)) {
+            lines.push(`             {${S.keyword}-fg}${file}{/}`);
+        }
+    }
+    lines.push('');
+    return lines;
+}
+export async function writeRunManifest({ runDir, runId, pipeline, cwd, stats, fileWrites, detectedDeliverables = [], status = 'done', error = null, debugEvents = [], }) {
+    if (!runDir)
+        return;
+    const uniqueWrites = [];
+    const seen = new Set();
+    for (const entry of [...fileWrites, ...detectedDeliverables]) {
+        if (seen.has(entry.absPath))
+            continue;
+        seen.add(entry.absPath);
+        uniqueWrites.push(entry);
+    }
+    const deliverables = uniqueWrites.filter((entry) => entry.kind === 'deliverable');
+    const intermediates = uniqueWrites.filter((entry) => entry.kind === 'intermediate');
+    const manifest = {
+        runId,
+        pipeline: pipeline.name,
+        projectRoot: cwd,
+        createdAt: new Date().toISOString(),
+        status,
+        error: error ? {
+            message: error.message,
+        } : null,
+        deliverables: deliverables.map((entry) => ({
+            path: entry.relPath,
+            absPath: entry.absPath,
+        })),
+        intermediates: intermediates.map((entry) => ({
+            path: entry.relPath,
+            absPath: entry.absPath,
+        })),
+        stats: stats.map((stat) => ({
+            agent: stat.agent,
+            provider: stat.provider,
+            model: stat.model,
+            runnerAgent: stat.runnerAgent,
+            securityProfile: stat.securityProfile,
+            permissionMode: stat.permissionMode,
+            status: stat.status,
+            seconds: stat.seconds,
+            turns: stat.turns,
+            cost: stat.cost,
+            attempts: stat.attempts || 1,
+            outputWarnings: stat.outputWarnings || [],
+            parsedOutputs: stat.parsedOutputs || [],
+            rawOutputPath: stat.rawOutputPath || null,
+        })),
+        debugEvents,
+    };
+    await fs.writeFile(path.join(runDir, 'run-manifest.json'), JSON.stringify(manifest, null, 2));
+}
+export async function writeLatestRunPointer({ cwd, runId }) {
+    const runsDir = path.join(cwd, '.singleton', 'runs');
+    await fs.mkdir(runsDir, { recursive: true });
+    await fs.writeFile(path.join(runsDir, LATEST_RUN_ID_FILE), `${runId}\n`);
+    const latest = path.join(runsDir, 'latest');
+    try {
+        const stat = await fs.lstat(latest);
+        if (stat.isSymbolicLink() || stat.isFile())
+            await fs.unlink(latest);
+    }
+    catch {
+        // Missing or non-removable legacy pointer is non-critical.
+    }
+    try {
+        await fs.symlink(runId, latest, 'dir');
+    }
+    catch { /* non-critical on Windows */ }
+}
+export async function resolveLatestRunDir(root) {
+    const runsDir = path.join(root, '.singleton', 'runs');
+    const pointer = path.join(runsDir, LATEST_RUN_ID_FILE);
+    try {
+        const runId = (await fs.readFile(pointer, 'utf8')).trim();
+        if (runId && !runId.includes('/') && !runId.includes('\\')) {
+            const runDir = path.join(runsDir, runId);
+            await fs.access(path.join(runDir, 'run-manifest.json'));
+            return runDir;
+        }
+    }
+    catch {
+        // Fall back to legacy symlink path below.
+    }
+    return path.join(runsDir, 'latest');
+}

package/dist/packages/cli/src/executor/run-setup.js

@@ -0,0 +1,114 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { style } from '../theme.js';
+import { createPlainTimeline, createTimeline } from '../timeline.js';
+import { G, S } from '../shell.js';
+import { collectInputValues } from './inputs.js';
+export function isNonInteractiveRuntime({ shell = null, nonInteractive = null, } = {}) {
+    if (shell)
+        return false;
+    if (typeof nonInteractive === 'boolean')
+        return nonInteractive;
+    return process.env.CI === 'true' || !process.stdout.isTTY;
+}
+export async function loadPipeline(filePath) {
+    const raw = await fs.readFile(filePath, 'utf8');
+    const pipeline = JSON.parse(raw);
+    if (!pipeline.steps || !Array.isArray(pipeline.steps)) {
+        throw new Error('Invalid pipeline: missing steps[]');
+    }
+    return pipeline;
+}
+// Project root = parent of the first `.singleton` segment found in pipelineDir.
+// Handles both .singleton/foo.json and .singleton/pipelines/foo.json.
+export function resolveProjectRoot(pipelineDir) {
+    const parts = pipelineDir.split(path.sep);
+    const idx = parts.indexOf('.singleton');
+    if (idx > 0)
+        return parts.slice(0, idx).join(path.sep) || path.sep;
+    return pipelineDir;
+}
+function createSilentTimeline() {
+    return {
+        log() { },
+        logMuted() { },
+        logSuccess() { },
+        logError() { },
+        logDiffLine() { },
+        setRunning() { },
+        setPaused() { },
+        setDone() { },
+        setError() { },
+        end() { },
+    };
+}
+export async function createRunWorkspace({ cwd, pipeline, dryRun, debug, }) {
+    const now = new Date();
+    const ts = `${now.getFullYear()}${String(now.getMonth() + 1).padStart(2, '0')}${String(now.getDate()).padStart(2, '0')}-${String(now.getHours()).padStart(2, '0')}${String(now.getMinutes()).padStart(2, '0')}${String(now.getSeconds()).padStart(2, '0')}`;
+    const runId = `${debug ? 'DEBUG-' : ''}${ts}-${pipeline.name}`;
+    const runDir = dryRun ? null : path.join(cwd, '.singleton', 'runs', runId);
+    if (runDir)
+        await fs.mkdir(runDir, { recursive: true });
+    return { runId, runDir };
+}
+export function logRunStart({ pipeline, cwd, runDir, dryRun, debug, shell, quiet, }) {
+    const runInfo = runDir ? `run: ${path.relative(cwd, runDir)}` : '';
+    if (!shell && !quiet) {
+        console.log(style.title(`\n${G.pointer} ${pipeline.name}`) + style.muted(`  (${pipeline.steps.length} steps)`));
+        if (runInfo)
+            console.log(style.muted(`  ${runInfo}`));
+        if (dryRun)
+            console.log(style.warn('  [dry-run] no CLI calls will be made'));
+        if (debug)
+            console.log(style.warn('  [debug] pausing before each step'));
+    }
+    else if (shell) {
+        shell.log(`{bold}${G.pointer} ${pipeline.name}{/}  {${S.muted}-fg}(${pipeline.steps.length} steps){/}`);
+        if (runInfo)
+            shell.log(`  {${S.muted}-fg}${runInfo}{/}`);
+        if (dryRun)
+            shell.log(`{yellow-fg}  [dry-run] no CLI calls will be made{/}`);
+        if (debug)
+            shell.log(`{yellow-fg}  [debug] pausing before each step{/}`);
+        shell.setMode?.('running');
+    }
+}
+function getInputDefs(pipeline) {
+    return (pipeline.nodes || [])
+        .filter((node) => node.type === 'input')
+        .map((node) => ({
+        id: node.id,
+        subtype: node.data?.subtype || 'text',
+        label: node.data?.label || node.id,
+        value: node.data?.value || '',
+    }));
+}
+export async function collectPipelineInputs({ pipeline, dryRun, shell, nonInteractive = false, quiet = false, }) {
+    const inputDefs = getInputDefs(pipeline);
+    // shell.prompt auto-toggles the frame to awaiting, so this only manages the label.
+    const promptFn = shell ? async (msg) => {
+        shell.setPipelineLabel?.('input waiting');
+        try {
+            return await shell.prompt(msg);
+        }
+        finally {
+            shell.clearPipelineLabel?.();
+        }
+    } : null;
+    const inputValues = await collectInputValues(pipeline, dryRun, {
+        promptFn,
+        style: quiet ? null : style,
+        nonInteractive,
+    });
+    return { inputDefs, inputValues };
+}
+export function createRunTimeline({ pipeline, quiet, shell, nonInteractive = false, }) {
+    if (shell)
+        shell.enterPipelineMode();
+    if (quiet)
+        return createSilentTimeline();
+    const stepNames = ['preflight checks', ...pipeline.steps.map((step) => step.agent)];
+    return nonInteractive && !shell
+        ? createPlainTimeline(stepNames)
+        : createTimeline(stepNames, shell ? shell.pipelineWidgets : null);
+}

package/dist/packages/cli/src/executor/security-review.js

@@ -0,0 +1,97 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { S } from '../shell.js';
+function runCommand(cmd, args, { cwd }) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(cmd, args, { cwd, 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', reject);
+        child.on('close', (code) => {
+            if (code !== 0) {
+                reject(new Error(stderr.trim() || stdout.trim() || `${cmd} exited ${code}`));
+                return;
+            }
+            resolve({ stdout, stderr });
+        });
+    });
+}
+export async function getViolationDiffPreview(cwd, relPath, { maxLines = 80 } = {}) {
+    try {
+        const { stdout } = await runCommand('git', ['diff', '--', relPath], { cwd });
+        const lines = stdout.trimEnd().split('\n').filter(Boolean);
+        if (lines.length === 0) {
+            try {
+                await runCommand('git', ['ls-files', '--error-unmatch', relPath], { cwd });
+                return ['No git diff available for this path.'];
+            }
+            catch {
+                try {
+                    const raw = await fs.readFile(path.join(cwd, relPath), 'utf8');
+                    const preview = raw.split('\n').slice(0, maxLines);
+                    if (raw.split('\n').length > maxLines) {
+                        preview.push(`... file preview truncated (${raw.split('\n').length - maxLines} more lines)`);
+                    }
+                    return [`new/untracked file: ${relPath}`, ...preview];
+                }
+                catch {
+                    return ['No git diff available for this path.'];
+                }
+            }
+        }
+        const clipped = lines.slice(0, maxLines);
+        if (lines.length > maxLines)
+            clipped.push(`... diff truncated (${lines.length - maxLines} more lines)`);
+        return clipped;
+    }
+    catch {
+        return ['No git diff available for this path.'];
+    }
+}
+async function logViolationDiffPreviews({ violations, cwd, timeline, }) {
+    const maxFiles = 5;
+    const shown = violations.slice(0, maxFiles);
+    for (const violation of shown) {
+        timeline.log(`── diff ${violation.path} ──`);
+        const preview = await getViolationDiffPreview(cwd, violation.path);
+        for (const line of preview)
+            timeline.logDiffLine(line);
+    }
+    if (violations.length > maxFiles) {
+        timeline.logMuted(`... ${violations.length - maxFiles} more violated file(s) not shown`);
+    }
+}
+export async function handlePostRunViolations({ violations, step, securityPolicy, timeline, timelineIndex, shell, cwd, failStep, }) {
+    if (violations.length === 0)
+        return;
+    timeline.log(`── post-run security violation ──`);
+    timeline.logMuted(`Step "${step.agent}" changed files outside its security policy.`);
+    timeline.logMuted(`security_profile: ${securityPolicy.profile}`);
+    for (const violation of violations) {
+        timeline.logMuted(`- ${violation.path}`);
+    }
+    await logViolationDiffPreviews({ violations, cwd, timeline });
+    if (!shell) {
+        failStep(timeline, timelineIndex, `${violations.length} security violation${violations.length > 1 ? 's' : ''}`, `Post-run security validation failed for "${step.agent}":\n- ${violations.map((violation) => violation.path).join('\n- ')}`);
+    }
+    const activeShell = shell;
+    while (true) {
+        const answer = (await activeShell.prompt('Security violation: continue, stop, or diff? (c/s/d)')).trim().toLowerCase();
+        if (answer === 'd' || answer === 'diff') {
+            await logViolationDiffPreviews({ violations, cwd, timeline });
+            continue;
+        }
+        if (answer === 'c' || answer === 'continue' || answer === 'y' || answer === 'yes') {
+            timeline.log(`{${S.warning}-fg}!{/} Continued after security violation for ${step.agent}.`);
+            return;
+        }
+        if (!answer || answer === 's' || answer === 'stop' || answer === 'n' || answer === 'no') {
+            break;
+        }
+        timeline.logMuted('Choose c/continue, s/stop, or d/diff.');
+    }
+    failStep(timeline, timelineIndex, 'stopped by security review', `Pipeline stopped after post-run security validation for "${step.agent}".`);
+}