sidecar-cli 0.1.5-beta.1 → 0.1.5-beta.2

package/dist/services/run-orchestrator-service.js

@@ -1,28 +1,84 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { spawn } from 'node:child_process';
 import { nowIso } from '../lib/format.js';
 import { compileTaskPrompt } from '../prompts/prompt-service.js';
 import { getTaskPacket } from '../tasks/task-service.js';
 import { getRunnerAdapter } from '../runners/factory.js';
-import { loadRunnerPreferences } from '../runners/config.js';
-import { updateRunRecordEntry } from '../runs/run-service.js';
+import { loadRunnerPreferences, loadReviewPreferences } from '../runners/config.js';
+import { getRunRecord, updateRunRecordEntry } from '../runs/run-service.js';
 import { saveTaskPacket } from '../tasks/task-service.js';
-export function runTaskExecution(input) {
+import { captureWorkingTreeSnapshot, captureFilesChangedSince, runValidationCommands, formatValidationResultsForRecord, normalizeValidationStep, } from '../runs/capture.js';
+// Open the compiled prompt in the user's editor before executing. Blocks the run until the
+// editor exits so the runner reads the saved edits. Falls back silently if no editor is
+// available or the spawn fails — the run proceeds with the unedited prompt.
+async function openPromptInEditor(promptPath) {
+    const editor = process.env.VISUAL || process.env.EDITOR || 'vi';
+    console.error(`Opening prompt in ${editor}: ${promptPath}`);
+    console.error('Save and exit the editor to continue the run.');
+    await new Promise((resolve) => {
+        try {
+            const child = spawn(editor, [promptPath], { stdio: 'inherit' });
+            child.on('close', () => resolve());
+            child.on('error', () => resolve());
+        }
+        catch {
+            resolve();
+        }
+    });
+}
+function toRunValidationEntry(r) {
+    return {
+        kind: r.kind,
+        command: r.command,
+        ...(r.name ? { name: r.name } : {}),
+        exit_code: r.exitCode,
+        ok: r.ok,
+        timed_out: r.timedOut,
+        duration_ms: r.durationMs,
+        timeout_ms: r.timeoutMs,
+        output_snippet: r.outputSnippet,
+    };
+}
+export async function runTaskExecution(input) {
     const prefs = loadRunnerPreferences(input.rootPath);
     const dryRun = Boolean(input.dryRun);
     const task = getTaskPacket(input.rootPath, input.taskId);
     const runner = input.runner ?? task.tracking.assigned_runner ?? prefs.default_runner;
     const agentRole = input.agentRole ?? task.tracking.assigned_agent_role ?? prefs.default_agent_role;
+    const worktree = (task.tracking.worktree ?? '').trim();
+    let cwd;
+    if (worktree.length > 0) {
+        if (!fs.existsSync(worktree)) {
+            throw new Error(`Task ${task.task_id} tracking.worktree points to ${worktree} but the directory does not exist.`);
+        }
+        cwd = worktree;
+    }
+    else {
+        cwd = input.rootPath;
+    }
     const compiled = compileTaskPrompt({
         rootPath: input.rootPath,
         taskId: task.task_id,
         runner,
         agentRole,
+        ...(input.parentRunId ? { parentRunId: input.parentRunId } : {}),
+        ...(input.replayReason ? { replayReason: input.replayReason } : {}),
+        ...(input.linkedContext ? { linkedContext: input.linkedContext } : {}),
+        ...(input.pipelineId ? { pipelineId: input.pipelineId } : {}),
+        ...(input.pipelineStep ? { pipelineStep: input.pipelineStep } : {}),
+        ...(input.pipelineTotal ? { pipelineTotal: input.pipelineTotal } : {}),
     });
+    if (input.editPrompt && !dryRun) {
+        await openPromptInEditor(compiled.prompt_path);
+    }
+    const logPath = path.resolve(path.join(input.rootPath, '.sidecar', 'runs', 'logs', `${compiled.run_id}.log`));
     const adapter = getRunnerAdapter(runner);
     saveTaskPacket(input.rootPath, { ...task, status: 'running' });
     updateRunRecordEntry(input.rootPath, compiled.run_id, {
         status: 'running',
         branch: task.tracking.branch,
-        worktree: task.tracking.worktree || input.rootPath,
+        worktree: cwd,
     });
     const prepared = adapter.prepare({
         runId: compiled.run_id,
@@ -31,20 +87,81 @@ export function runTaskExecution(input) {
         promptPath: compiled.prompt_path,
         projectRoot: input.rootPath,
     });
-    const executed = adapter.execute({ prepared, dryRun });
+    const preRunSnapshot = !dryRun ? await captureWorkingTreeSnapshot(cwd) : null;
+    const executed = await adapter.execute({
+        prepared,
+        dryRun,
+        cwd,
+        logPath,
+        streamOutput: input.streamOutput,
+    });
     const collected = adapter.collectResult(executed);
-    const finishedStatus = collected.ok ? 'completed' : 'failed';
-    const nextTaskStatus = collected.ok ? 'review' : 'blocked';
-    saveTaskPacket(input.rootPath, { ...getTaskPacket(input.rootPath, task.task_id), status: nextTaskStatus });
+    let ok = collected.ok;
+    const blockers = [...collected.blockers];
+    let validationResults = collected.validationResults;
+    let validationEntries = [];
+    let validationFailed = false;
+    let validationAttempted = false;
+    let changedFiles = [];
+    if (!dryRun && collected.executed && preRunSnapshot) {
+        changedFiles = await captureFilesChangedSince(cwd, preRunSnapshot);
+    }
+    if (!dryRun && collected.executed && ok) {
+        const configured = task.execution?.commands?.validation ?? [];
+        const steps = [];
+        for (const entry of configured) {
+            const normalized = normalizeValidationStep(entry);
+            if (normalized)
+                steps.push(normalized);
+        }
+        if (steps.length > 0) {
+            validationAttempted = true;
+            const results = await runValidationCommands(cwd, steps, logPath);
+            validationResults = formatValidationResultsForRecord(results);
+            validationEntries = results.map(toRunValidationEntry);
+            const failed = results.filter((r) => !r.ok);
+            if (failed.length > 0) {
+                validationFailed = true;
+                ok = false;
+                for (const f of failed) {
+                    blockers.push(`validation failed (${f.kind}): ${f.command}`);
+                }
+            }
+        }
+    }
+    const finishedStatus = ok ? 'completed' : 'failed';
+    const nextTaskStatus = ok ? 'review' : 'blocked';
+    // Auto-approve on all-green is opt-in via preferences. We only auto-approve when at least
+    // one validation step actually ran and every step passed — a runner-only success with no
+    // validation configured still requires a human click.
+    const reviewPrefs = loadReviewPreferences(input.rootPath);
+    const shouldAutoApprove = reviewPrefs.auto_approve_on_all_green && ok && validationAttempted && validationEntries.every((e) => e.ok);
+    saveTaskPacket(input.rootPath, {
+        ...getTaskPacket(input.rootPath, task.task_id),
+        status: nextTaskStatus,
+    });
     updateRunRecordEntry(input.rootPath, compiled.run_id, {
         status: finishedStatus,
         completed_at: nowIso(),
         summary: collected.summary,
         commands_run: collected.commandsRun,
-        validation_results: collected.validationResults,
-        blockers: collected.blockers,
+        validation_results: validationResults,
+        validation: validationEntries,
+        blockers,
         follow_ups: collected.followUps,
+        changed_files: changedFiles,
+        ...(shouldAutoApprove
+            ? {
+                review_state: 'approved',
+                reviewed_at: nowIso(),
+                reviewed_by: 'sidecar:auto',
+                review_note: `Auto-approved: ${validationEntries.length} validation step(s) passed`,
+            }
+            : {}),
     });
+    const summary = validationFailed
+        ? `Runner ok, but validation failed. ${collected.summary}`
+        : collected.summary;
     return {
         task_id: task.task_id,
         run_id: compiled.run_id,
@@ -54,6 +171,88 @@ export function runTaskExecution(input) {
         status: finishedStatus,
         dry_run: dryRun,
         shell_command: prepared.shellLine,
-        summary: collected.summary,
+        summary,
+        changed_files: changedFiles,
+        log_path: dryRun ? null : logPath,
+        duration_ms: executed.durationMs ?? 0,
     };
 }
+function generatePipelineId() {
+    const ts = Date.now().toString(36);
+    const rand = Math.random().toString(36).slice(2, 8);
+    return `PL-${ts}-${rand}`;
+}
+function tailLogFile(logPath, maxChars) {
+    if (!logPath)
+        return '';
+    try {
+        const raw = fs.readFileSync(logPath, 'utf8');
+        return raw.length > maxChars ? raw.slice(raw.length - maxChars) : raw;
+    }
+    catch {
+        return '';
+    }
+}
+function summarizeRunForPipeline(rootPath, step) {
+    let validationSummary;
+    try {
+        const record = getRunRecord(rootPath, step.run_id);
+        const v = record.validation ?? [];
+        if (v.length > 0) {
+            const ok = v.filter((x) => x.ok).length;
+            const failed = v.filter((x) => !x.ok && !x.timed_out).length;
+            const timed = v.filter((x) => x.timed_out).length;
+            const parts = [`${ok}/${v.length} ok`];
+            if (failed > 0)
+                parts.push(`${failed} failed`);
+            if (timed > 0)
+                parts.push(`${timed} timed-out`);
+            validationSummary = parts.join(', ');
+        }
+    }
+    catch {
+        // missing record shouldn't block the next step — leave summary blank
+    }
+    return {
+        run_id: step.run_id,
+        runner: step.runner_type,
+        agent_role: step.agent_role,
+        status: step.status,
+        summary: step.summary,
+        changed_files: step.changed_files,
+        ...(validationSummary ? { validation_summary: validationSummary } : {}),
+        log_tail: tailLogFile(step.log_path, 1500),
+    };
+}
+// Sequential dual-runner pipeline. Each step sees all prior steps' summaries
+// (run id, runner, validation outcome, changed files, log tail) as
+// `previous_runs` linked context on its compiled prompt. Runs share a
+// `pipeline_id` and carry 1-based `pipeline_step` + `pipeline_total` so the
+// chain is reconstructable. A step that fails does NOT short-circuit the
+// pipeline — downstream runners may be set up explicitly to fix failures.
+export async function runPipelineExecution(input) {
+    if (input.runners.length === 0)
+        throw new Error('runPipelineExecution requires at least one runner');
+    const pipelineId = generatePipelineId();
+    const steps = [];
+    for (let i = 0; i < input.runners.length; i++) {
+        const runner = input.runners[i];
+        const previousRuns = steps.map((s) => summarizeRunForPipeline(input.rootPath, s));
+        const linkedContext = previousRuns.length > 0 ? { previous_runs: previousRuns } : undefined;
+        const stepResult = await runTaskExecution({
+            rootPath: input.rootPath,
+            taskId: input.taskId,
+            runner,
+            ...(input.agentRole ? { agentRole: input.agentRole } : {}),
+            ...(input.dryRun != null ? { dryRun: input.dryRun } : {}),
+            ...(input.streamOutput ? { streamOutput: input.streamOutput } : {}),
+            ...(input.editPrompt != null ? { editPrompt: input.editPrompt } : {}),
+            ...(linkedContext ? { linkedContext } : {}),
+            pipelineId,
+            pipelineStep: i + 1,
+            pipelineTotal: input.runners.length,
+        });
+        steps.push(stepResult);
+    }
+    return { pipeline_id: pipelineId, steps };
+}

package/dist/services/run-review-service.js

@@ -52,7 +52,7 @@ export function createFollowupTaskFromRun(rootPath, runId) {
         files_to_avoid: sourceTask.implementation.files_to_avoid,
         technical_constraints: sourceTask.constraints.technical,
         design_constraints: sourceTask.constraints.design,
-        validation_commands: sourceTask.execution.commands.validation,
+        validation_commands: sourceTask.execution.commands.validation.map((v) => ({ ...v })),
         definition_of_done: [...sourceTask.definition_of_done, ...suggestions],
     });
     return {

package/dist/tasks/task-packet.js

@@ -6,6 +6,23 @@ export const taskPacketPrioritySchema = z.enum(['low', 'medium', 'high']);
 export const taskPacketTypeSchema = z.enum(['feature', 'bug', 'chore', 'research']);
 export const taskAgentRoleSchema = z.enum(['planner', 'builder-ui', 'builder-app', 'reviewer', 'tester']);
 export const taskRunnerSchema = z.enum(['codex', 'claude']);
+export const validationKindSchema = z.enum(['typecheck', 'lint', 'test', 'build', 'custom']);
+// Accept string entries ("npm test") or object entries ({kind,command,...}). String entries
+// are promoted to { kind: 'custom', command }. This preserves the v1 packet shape while
+// giving new packets first-class typed validation steps.
+export const validationStepSchema = z.preprocess((raw) => {
+    if (typeof raw === 'string') {
+        return { kind: 'custom', command: raw };
+    }
+    return raw;
+}, z
+    .object({
+    kind: validationKindSchema.default('custom'),
+    command: z.string().min(1, 'validation command is required'),
+    name: z.string().optional(),
+    timeout_ms: z.number().int().positive().optional(),
+})
+    .strict());
 export const taskPacketSchema = z
     .object({
     version: z.string().default(TASK_PACKET_VERSION),
@@ -42,7 +59,7 @@ export const taskPacketSchema = z
     }),
     execution: z.object({
         commands: z.object({
-            validation: z.array(z.string()).default([]),
+            validation: z.array(validationStepSchema).default([]),
         }),
     }),
     dependencies: z.array(taskIdSchema).default([]),

package/dist/tasks/task-service.js

@@ -1,5 +1,6 @@
 import { TaskPacketRepository } from './task-repository.js';
 import { createTaskPacket, } from './task-packet.js';
+import { normalizeValidationStep } from '../runs/capture.js';
 export function createTaskPacketRecord(rootPath, input) {
     const repo = new TaskPacketRepository(rootPath);
     const taskId = repo.generateNextTaskId();
@@ -28,7 +29,9 @@ export function createTaskPacketRecord(rootPath, input) {
         },
         execution: {
             commands: {
-                validation: input.validation_commands ?? [],
+                validation: (input.validation_commands ?? [])
+                    .map((v) => normalizeValidationStep(v))
+                    .filter((v) => v !== null),
             },
         },
         dependencies: input.dependencies ?? [],

package/dist/templates/hooks.js

@@ -0,0 +1,34 @@
+// Claude Code hook settings template for Sidecar ambient capture.
+// Drop into .claude/settings.json (project) or ~/.claude/settings.json (user) —
+// Claude Code merges arrays across scopes.
+//
+// Also referenced from the README "Ambient capture via hooks" section and emitted
+// by `sidecar hooks print` for copy/paste.
+export const CLAUDE_CODE_HOOK_SETTINGS = {
+    hooks: {
+        SessionStart: [
+            {
+                hooks: [{ type: 'command', command: 'sidecar hook session-start' }],
+            },
+        ],
+        SessionEnd: [
+            {
+                hooks: [{ type: 'command', command: 'sidecar hook session-end' }],
+            },
+        ],
+        PostToolUse: [
+            {
+                matcher: 'Edit|Write|MultiEdit|NotebookEdit',
+                hooks: [{ type: 'command', command: 'sidecar hook file-edit' }],
+            },
+        ],
+        UserPromptSubmit: [
+            {
+                hooks: [{ type: 'command', command: 'sidecar hook user-prompt' }],
+            },
+        ],
+    },
+};
+export function renderClaudeCodeHooksJson() {
+    return JSON.stringify(CLAUDE_CODE_HOOK_SETTINGS, null, 2);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sidecar-cli",
-  "version": "0.1.5-beta.1",
+  "version": "0.1.5-beta.2",
   "description": "Local-first project memory and recording tool",
   "scripts": {
     "build": "npm run clean && tsc -p tsconfig.json",
@@ -29,6 +29,7 @@
     "chalk": "^5.6.2",
     "commander": "^14.0.3",
     "semver": "^7.7.4",
+    "yaml": "^2.8.3",
     "zod": "^4.3.6"
   },
   "devDependencies": {