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

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

@@ -0,0 +1,189 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { S } from '../shell.js';
+
+function visibleLength(s) {
+  return String(s || '').replace(/\{[^}]+\}/g, '').length;
+}
+
+function padVisible(s, width, align = 'left') {
+  const str = String(s ?? '');
+  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) {
+  return value > 0 ? `$${value.toFixed(4)}` : '—';
+}
+
+function formatTurns(value) {
+  return value > 0 ? 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}${'─'.repeat(left)}{/}{${S.accent}-fg}{bold}${text}{/}{${S.subtle}-fg}${'─'.repeat(right)}{/}`,
+    '',
+  ];
+}
+
+export function renderRunSummary({ stats, fileWrites, dryRun, runDir, cwd, runStatus = null }) {
+  const totalSeconds = stats.reduce((sum, s) => sum + (s.seconds || 0), 0);
+  const totalCost = stats.reduce((sum, s) => sum + (s.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((s, i) => ({
+    step: String(i + 1),
+    agent: s.agent,
+    model: s.model || '—',
+    status: s.status,
+    time: s.status === 'dry-run' || s.status === 'skipped' ? '—' : formatSeconds(s.seconds),
+    cost: formatCost(s.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((r) => visibleLength(r.step))),
+    agent: Math.max(5, ...allRows.map((r) => visibleLength(r.agent))),
+    model: Math.max(5, ...allRows.map((r) => visibleLength(r.model))),
+    status: Math.max(6, ...allRows.map((r) => visibleLength(r.status))),
+    time: Math.max(4, ...allRows.map((r) => visibleLength(r.time))),
+    cost: Math.max(4, ...allRows.map((r) => visibleLength(r.cost))),
+  };
+
+  const hr = [
+    '─'.repeat(widths.step + 2),
+    '─'.repeat(widths.agent + 2),
+    '─'.repeat(widths.model + 2),
+    '─'.repeat(widths.status + 2),
+    '─'.repeat(widths.time + 2),
+    '─'.repeat(widths.cost + 2),
+  ].join(`{${S.subtle}-fg}┼{/}`);
+
+  // Bold each cell individually because `{/}` from the separator would reset a row-level bold.
+  function row(r, { bold = false, colorStatus = false } = {}) {
+    const b = bold ? '{bold}' : '';
+    const bClose = bold ? '{/}' : '';
+    const statusPadded = padVisible(r.status, widths.status);
+    const statusCell = colorStatus
+      ? `{${statusColor(r.status)}-fg}${b}${statusPadded}${bClose}{/}`
+      : `${b}${statusPadded}${bClose}`;
+    return [
+      ` ${b}${padVisible(r.step, widths.step, 'right')}${bClose} `,
+      ` ${b}${padVisible(r.agent, widths.agent)}${bClose} `,
+      ` ${b}${padVisible(r.model, widths.model)}${bClose} `,
+      ` ${statusCell} `,
+      ` ${b}${padVisible(r.time, widths.time, 'right')}${bClose} `,
+      ` ${b}${padVisible(r.cost, widths.cost, 'right')}${bClose} `,
+    ].join(`{${S.subtle}-fg}│{/}`);
+  }
+
+  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((r) => row(r, { 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 f of fileWrites.slice(1)) {
+      lines.push(`             {${S.keyword}-fg}${f}{/}`);
+    }
+  }
+  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((s) => ({
+      agent: s.agent,
+      provider: s.provider,
+      model: s.model,
+      runnerAgent: s.runnerAgent,
+      securityProfile: s.securityProfile,
+      permissionMode: s.permissionMode,
+      status: s.status,
+      seconds: s.seconds,
+      turns: s.turns,
+      cost: s.cost,
+      attempts: s.attempts || 1,
+      outputWarnings: s.outputWarnings || [],
+      parsedOutputs: s.parsedOutputs || [],
+      rawOutputPath: s.rawOutputPath || null,
+    })),
+    debugEvents,
+  };
+
+  await fs.writeFile(path.join(runDir, 'run-manifest.json'), JSON.stringify(manifest, null, 2));
+}

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

@@ -0,0 +1,93 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { style } from '../theme.js';
+import { createTimeline } from '../timeline.js';
+import { S } from '../shell.js';
+import { collectInputValues } from './inputs.js';
+
+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▸ ${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}▸ ${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((n) => n.type === 'input')
+    .map((n) => ({ id: n.id, subtype: n.data?.subtype || 'text', label: n.data?.label || n.id, value: n.data?.value || '' }));
+}
+
+export async function collectPipelineInputs({ pipeline, dryRun, shell }) {
+  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 });
+  return { inputDefs, inputValues };
+}
+
+export function createRunTimeline({ pipeline, quiet, shell }) {
+  if (shell) shell.enterPipelineMode();
+  return quiet
+    ? createSilentTimeline()
+    : createTimeline(
+        ['preflight checks', ...pipeline.steps.map((s) => s.agent)],
+        shell ? shell.pipelineWidgets : null
+      );
+}

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

@@ -0,0 +1,108 @@
+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', (d) => (stdout += d.toString()));
+    child.stderr.on('data', (d) => (stderr += d.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((v) => v.path).join('\n- ')}`
+    );
+  }
+
+  while (true) {
+    const answer = (await shell.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}".`
+  );
+}