@weldr/runr 0.4.0 → 0.7.2

package/dist/commands/init.js

@@ -1,5 +1,10 @@
 import fs from 'node:fs';
+import fsPromises from 'node:fs/promises';
 import path from 'node:path';
+import { getWorkflowProfileDefaults } from '../config/schema.js';
+import { loadPackByName } from '../packs/loader.js';
+import { executeActions } from '../packs/actions.js';
+import { formatVerificationCommands } from '../packs/renderer.js';
 /**
  * Detect Python project verification commands
  */
@@ -191,7 +196,7 @@ function generateDefaultConfig(repoPath) {
 /**
  * Build config object from detection results
  */
-function buildConfig(repoPath, detection) {
+function buildConfig(repoPath, detection, workflowProfile) {
     const hasSrc = fs.existsSync(path.join(repoPath, 'src'));
     const hasTests = fs.existsSync(path.join(repoPath, 'tests')) ||
         fs.existsSync(path.join(repoPath, 'test'));
@@ -207,7 +212,7 @@ function buildConfig(repoPath, detection) {
         // Default: allow everything except common excludes
         allowlist.push('**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx');
     }
-    return {
+    const config = {
         agent: {
             name: path.basename(repoPath),
             version: '1'
@@ -259,8 +264,18 @@ function buildConfig(repoPath, detection) {
             auto_resume_delays_ms: [30000, 120000, 300000],
             max_worker_call_minutes: 45,
             max_review_rounds: 2
+        },
+        receipts: {
+            redact: true,
+            capture_cmd_output: 'truncated',
+            max_output_bytes: 10240
         }
     };
+    // Add workflow config if profile specified
+    if (workflowProfile) {
+        config.workflow = getWorkflowProfileDefaults(workflowProfile);
+    }
+    return config;
 }
 /**
  * Create example task files
@@ -317,10 +332,207 @@ Update documentation for [topic/module]
     fs.writeFileSync(path.join(tasksDir, 'example-feature.md'), exampleFeature);
     fs.writeFileSync(path.join(tasksDir, 'example-docs.md'), exampleDocs);
 }
+/**
+ * Ensure .gitignore contains the specified entry.
+ * Returns true if entry was added, false if already present.
+ */
+async function ensureGitignoreEntry(repoPath, entry) {
+    const gitignorePath = path.join(repoPath, '.gitignore');
+    let content = '';
+    try {
+        content = await fsPromises.readFile(gitignorePath, 'utf-8');
+    }
+    catch {
+        // No .gitignore exists, will create one
+    }
+    // Check if entry already exists
+    const lines = content.split('\n');
+    const hasEntry = lines.some(line => line.trim() === entry.trim());
+    if (!hasEntry) {
+        const newContent = content.endsWith('\n') || content === ''
+            ? `${content}${entry}\n`
+            : `${content}\n${entry}\n`;
+        await fsPromises.writeFile(gitignorePath, newContent);
+        return true; // Added
+    }
+    return false; // Already present
+}
+/**
+ * Generate the demo project
+ */
+async function generateDemoProject(demoDir) {
+    fs.mkdirSync(demoDir, { recursive: true });
+    fs.mkdirSync(path.join(demoDir, 'src'), { recursive: true });
+    fs.mkdirSync(path.join(demoDir, 'tests'), { recursive: true });
+    fs.mkdirSync(path.join(demoDir, '.runr', 'tasks'), { recursive: true });
+    const packageJson = {
+        name: 'runr-demo',
+        version: '1.0.0',
+        type: 'module',
+        scripts: { test: 'vitest run', typecheck: 'tsc --noEmit' },
+        devDependencies: { typescript: '^5.0.0', vitest: '^1.0.0' }
+    };
+    fs.writeFileSync(path.join(demoDir, 'package.json'), JSON.stringify(packageJson, null, 2) + '\n');
+    const tsconfig = {
+        compilerOptions: {
+            target: 'ES2022', module: 'ESNext', moduleResolution: 'node',
+            strict: true, esModuleInterop: true, skipLibCheck: true, outDir: 'dist'
+        },
+        include: ['src/**/*', 'tests/**/*']
+    };
+    fs.writeFileSync(path.join(demoDir, 'tsconfig.json'), JSON.stringify(tsconfig, null, 2) + '\n');
+    fs.writeFileSync(path.join(demoDir, 'src', 'math.ts'), `/**
+ * Simple math functions for demo
+ */
+export function add(a: number, b: number): number { return a + b; }
+export function subtract(a: number, b: number): number { return a - b; }
+// TODO: implement multiply
+`);
+    fs.writeFileSync(path.join(demoDir, 'tests', 'math.test.ts'), `import { describe, it, expect } from 'vitest';
+import { add, subtract } from '../src/math.js';
+
+describe('math', () => {
+  it('adds two numbers', () => { expect(add(2, 3)).toBe(5); });
+  it('subtracts two numbers', () => { expect(subtract(5, 3)).toBe(2); });
+});
+`);
+    const runrConfig = {
+        agent: { name: 'runr-demo', version: '1' },
+        scope: {
+            allowlist: ['src/**', 'tests/**', '.runr/**'],
+            denylist: ['node_modules/**', 'README.md'],
+            lockfiles: ['package-lock.json'],
+            presets: ['typescript', 'vitest']
+        },
+        verification: { tier0: ['npm run typecheck'], tier1: ['npm test'] },
+        workers: { claude: { bin: 'claude', args: ['-p', '--output-format', 'json', '--dangerously-skip-permissions'], output: 'json' } },
+        phases: { plan: 'claude', implement: 'claude', review: 'claude' },
+        workflow: { profile: 'solo', mode: 'flow', integration_branch: 'main', require_verification: true, require_clean_tree: true }
+    };
+    fs.writeFileSync(path.join(demoDir, '.runr', 'runr.config.json'), JSON.stringify(runrConfig, null, 2) + '\n');
+    fs.writeFileSync(path.join(demoDir, '.runr', 'tasks', '00-success.md'), `# Implement multiply function
+
+## Goal
+Add a multiply function to src/math.ts and add a test for it.
+
+## Requirements
+- Add \`multiply(a: number, b: number): number\` to src/math.ts
+- Add a test in tests/math.test.ts
+
+## Success Criteria
+- npm run typecheck passes
+- npm test passes
+`);
+    fs.writeFileSync(path.join(demoDir, '.runr', 'tasks', '01-intentional-fail.md'), `# Add divide function with edge case
+
+## Goal
+Add a divide function with tests including edge cases.
+
+## Requirements
+- Add \`divide(a: number, b: number): number\` to src/math.ts
+- Add tests including divide(10, 2) === 5 and divide(10, 0) === Infinity
+
+## Success Criteria
+- npm run typecheck passes
+- npm test passes
+`);
+    fs.writeFileSync(path.join(demoDir, '.runr', 'tasks', '02-scope-violation.md'), `# Update README with project description
+
+## Goal
+Update README.md to describe this math library.
+
+## Requirements
+- Add a description of the available functions
+- Add usage examples
+
+## Success Criteria
+- README.md contains function documentation
+
+## Note
+This task will trigger a scope violation because README.md is in the denylist.
+`);
+    fs.writeFileSync(path.join(demoDir, 'README.md'), `# Runr Demo
+
+Try Runr in 2 minutes.
+
+## Step 1: Install
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Step 2: Run the tasks
+
+### Task 00: Success (quick win)
+
+\`\`\`bash
+runr run --task .runr/tasks/00-success.md
+\`\`\`
+
+**Expected:** Completes cleanly. The agent adds a multiply function and test.
+
+\`\`\`bash
+runr report latest   # see what happened
+\`\`\`
+
+### Task 01: Failure + Recovery
+
+\`\`\`bash
+runr run --task .runr/tasks/01-intentional-fail.md
+\`\`\`
+
+**Expected:** May stop (verification failed or review loop). This is intentional.
+
+\`\`\`bash
+runr                 # shows STOPPED + 3 next actions
+runr continue        # attempt auto-fix
+runr report latest
+\`\`\`
+
+### Task 02: Scope Guard
+
+\`\`\`bash
+runr run --task .runr/tasks/02-scope-violation.md
+\`\`\`
+
+**Expected:** STOPPED (scope guard). README.md is in the denylist.
+
+This demonstrates the safety guardrails.
+
+## The point
+
+Runr stops with receipts and 3 next actions you can trust:
+- **continue** — auto-fix what's safe, then resume
+- **report** — open the run receipt: diffs + logs + timeline
+- **intervene** — record manual fixes
+`);
+    fs.writeFileSync(path.join(demoDir, '.gitignore'), 'node_modules/\ndist/\n.runr/runs/\n');
+}
 /**
  * Initialize Runr configuration for a repository
  */
 export async function initCommand(options) {
+    // Handle --demo flag
+    if (options.demo) {
+        const demoDir = path.resolve(options.demoDir || 'runr-demo');
+        if (fs.existsSync(demoDir)) {
+            if (!options.force) {
+                console.error(`Error: ${demoDir} already exists. Use --force to overwrite.`);
+                process.exit(1);
+            }
+            fs.rmSync(demoDir, { recursive: true, force: true });
+        }
+        console.log('Creating demo project...\n');
+        await generateDemoProject(demoDir);
+        console.log(`✅ Demo created at ${demoDir}\n`);
+        console.log('Next steps:');
+        console.log(`  cd ${path.basename(demoDir)}`);
+        console.log('  npm install');
+        console.log('  runr run --task .runr/tasks/00-success.md');
+        console.log('');
+        console.log('See README.md in the demo for the full walkthrough.');
+        return;
+    }
     const repoPath = path.resolve(options.repo);
     const runrDir = path.join(repoPath, '.runr');
     const configPath = path.join(runrDir, 'runr.config.json');
@@ -333,32 +545,180 @@ export async function initCommand(options) {
         process.exit(0);
     }
     // Check if config already exists
-    if (fs.existsSync(configPath) && !options.force) {
+    if (fs.existsSync(configPath) && !options.force && !options.dryRun) {
         console.error('Error: .runr/runr.config.json already exists');
         console.error('Use --force to overwrite');
         process.exit(1);
     }
+    // Load pack if specified
+    let pack = null;
+    if (options.pack) {
+        pack = loadPackByName(options.pack);
+        if (!pack) {
+            console.error(`Error: Pack "${options.pack}" not found`);
+            console.error('Run "runr tools packs" to see available packs');
+            process.exit(1);
+        }
+        if (!pack.validation.valid) {
+            console.error(`Error: Pack "${options.pack}" is invalid:`);
+            for (const error of pack.validation.errors) {
+                console.error(`  - ${error}`);
+            }
+            process.exit(1);
+        }
+    }
     // Detect verification commands - try Python first, then package.json, then default
     const detection = detectPythonVerification(repoPath) ||
         detectFromPackageJson(repoPath) ||
         generateDefaultConfig(repoPath);
+    // Determine workflow profile (pack defaults override --workflow flag)
+    let workflowProfile = options.workflow;
+    if (pack?.manifest.defaults?.profile) {
+        workflowProfile = pack.manifest.defaults.profile;
+    }
     // Build config
-    const config = buildConfig(repoPath, detection);
+    const config = buildConfig(repoPath, detection, workflowProfile);
+    // Apply pack defaults to config if pack is loaded
+    if (pack?.manifest.defaults) {
+        const packDefaults = pack.manifest.defaults;
+        // Ensure workflow config exists
+        if (!config.workflow) {
+            config.workflow = {
+                profile: packDefaults.profile || 'solo',
+                mode: packDefaults.mode || 'flow',
+                integration_branch: packDefaults.integration_branch || 'main',
+                submit_strategy: 'cherry-pick',
+                require_clean_tree: packDefaults.require_clean_tree ?? true,
+                require_verification: packDefaults.require_verification ?? true
+            };
+        }
+        else {
+            // Apply pack defaults to existing workflow config
+            if (packDefaults.profile)
+                config.workflow.profile = packDefaults.profile;
+            if (packDefaults.integration_branch)
+                config.workflow.integration_branch = packDefaults.integration_branch;
+            if (packDefaults.submit_strategy)
+                config.workflow.submit_strategy = packDefaults.submit_strategy;
+            if (packDefaults.require_clean_tree !== undefined)
+                config.workflow.require_clean_tree = packDefaults.require_clean_tree;
+            if (packDefaults.require_verification !== undefined)
+                config.workflow.require_verification = packDefaults.require_verification;
+        }
+    }
     // If --print mode, just output and exit
     if (options.print) {
         console.log(JSON.stringify(config, null, 2));
         return;
     }
+    // Handle --dry-run mode (pack actions only)
+    if (options.dryRun && pack) {
+        console.log('[DRY RUN] Pack-based initialization plan:\n');
+        console.log(`Pack: ${pack.manifest.display_name}`);
+        console.log(`Description: ${pack.manifest.description}\n`);
+        console.log('Config changes:');
+        console.log(`  - Workflow profile: ${config.workflow?.profile || 'none'}`);
+        console.log(`  - Integration branch: ${config.workflow?.integration_branch || 'none'}`);
+        console.log(`  - Require verification: ${config.workflow?.require_verification}`);
+        console.log(`  - Require clean tree: ${config.workflow?.require_clean_tree}\n`);
+        if (pack.manifest.init_actions && pack.manifest.init_actions.length > 0) {
+            console.log('Init actions:');
+            const templateContext = {
+                project_name: options.about || path.basename(repoPath),
+                project_about: options.about || `Project: ${path.basename(repoPath)}`,
+                verification_commands: formatVerificationCommands(config.verification),
+                integration_branch: config.workflow?.integration_branch || 'main',
+                release_branch: pack.manifest.defaults?.release_branch || 'main',
+                pack_name: pack.manifest.name
+            };
+            const actionContext = {
+                repoPath,
+                packDir: pack.packDir,
+                templates: pack.manifest.templates || {},
+                templateContext,
+                flags: {
+                    with_claude: options.withClaude || false
+                },
+                dryRun: true
+            };
+            const results = await executeActions(pack.manifest.init_actions, actionContext);
+            for (const result of results) {
+                console.log(`  ${result.message}`);
+            }
+        }
+        return;
+    }
     // Create .runr directory
-    fs.mkdirSync(runrDir, { recursive: true });
+    if (!options.dryRun) {
+        fs.mkdirSync(runrDir, { recursive: true });
+    }
+    // Execute pack actions if pack is loaded
+    if (pack?.manifest.init_actions) {
+        const templateContext = {
+            project_name: options.about || path.basename(repoPath),
+            project_about: options.about || `Project: ${path.basename(repoPath)}`,
+            verification_commands: formatVerificationCommands(config.verification),
+            integration_branch: config.workflow?.integration_branch || 'main',
+            release_branch: pack.manifest.defaults?.release_branch || 'main',
+            pack_name: pack.manifest.name
+        };
+        const actionContext = {
+            repoPath,
+            packDir: pack.packDir,
+            templates: pack.manifest.templates || {},
+            templateContext,
+            flags: {
+                with_claude: options.withClaude || false
+            },
+            dryRun: false
+        };
+        const results = await executeActions(pack.manifest.init_actions, actionContext);
+        for (const result of results) {
+            if (result.error) {
+                console.log(`❌ ${result.message}: ${result.error}`);
+            }
+            else if (result.executed) {
+                console.log(`✅ ${result.message}`);
+            }
+            else {
+                console.log(`✓ ${result.message}`);
+            }
+        }
+    }
+    else {
+        // Legacy path: ensure .runr/ is gitignored if no pack actions
+        const added = await ensureGitignoreEntry(repoPath, '.runr/');
+        if (added) {
+            console.log('✅ Added .runr/ to .gitignore');
+        }
+        else {
+            console.log('✓ .runr/ already in .gitignore');
+        }
+        console.log('');
+        console.log('💡 Tip: runr init --pack solo --dry-run to preview workflow scaffolding');
+        console.log('');
+    }
     // Write config
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
-    // Create example tasks
-    createExampleTasks(runrDir);
+    if (!options.dryRun) {
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+    }
+    // Create example tasks (only if no pack is loaded)
+    if (!pack && !options.dryRun) {
+        createExampleTasks(runrDir);
+    }
     // Report results
     console.log('✅ Runr initialized successfully!\n');
     console.log(`Config written to: ${configPath}`);
     console.log(`Example tasks created in: ${path.join(runrDir, 'tasks')}/\n`);
+    // Report workflow config if set
+    if (options.workflow && config.workflow) {
+        console.log('Workflow configuration:');
+        console.log(`  profile: ${config.workflow.profile}`);
+        console.log(`  integration_branch: ${config.workflow.integration_branch}`);
+        console.log(`  require_verification: ${config.workflow.require_verification}`);
+        console.log(`  require_clean_tree: ${config.workflow.require_clean_tree}`);
+        console.log('');
+    }
     if (detection.source === 'package.json') {
         console.log('Detected from package.json:');
         if (detection.verification.tier0.length > 0) {

package/dist/commands/intervene.js

@@ -0,0 +1,109 @@
+/**
+ * runr intervene - Record manual work done outside Runr's normal flow.
+ *
+ * When the meta-agent (or you) routes around friction, this command
+ * creates a structured intervention receipt so the audit trail stays intact.
+ *
+ * Usage:
+ *   runr intervene <run_id> --reason review_loop --note "Fixed TS errors" --cmd "npm test"
+ *   runr intervene --latest --reason manual_fix --note "Added missing import"
+ */
+import { RunStore } from '../store/run-store.js';
+import { resolveRunId } from '../store/run-utils.js';
+import { writeIntervention, printInterventionReceipt } from '../receipt/intervention.js';
+import { getCurrentMode, checkModeRestriction } from './mode.js';
+import { checkAmendAllowed } from '../guards/checkpoint.js';
+const VALID_REASONS = [
+    'review_loop',
+    'stalled_timeout',
+    'verification_failed',
+    'scope_violation',
+    'manual_fix',
+    'other'
+];
+export async function interveneCommand(options) {
+    const { repo, reason, note, commands, json, cmdOutput, noRedact, since, commit, amendLast, stageOnly, force } = options;
+    // Get workflow mode for error messages
+    const workflowMode = getCurrentMode(repo);
+    const isLedgerMode = workflowMode === 'ledger';
+    // Check if HEAD is a checkpoint commit (blocks amend even in Flow mode)
+    if (amendLast) {
+        const checkpointCheck = checkAmendAllowed(repo, force, isLedgerMode);
+        if (!checkpointCheck.allowed) {
+            console.error(checkpointCheck.error);
+            process.exitCode = 1;
+            return;
+        }
+        // Print warning if force was used on checkpoint
+        if (checkpointCheck.error && force) {
+            console.error(checkpointCheck.error);
+        }
+    }
+    // Check mode restrictions for --amend-last (Ledger mode blocks all amends)
+    if (amendLast) {
+        const check = checkModeRestriction(repo, 'amend_last', force);
+        if (!check.allowed) {
+            console.error(check.error);
+            process.exitCode = 1;
+            return;
+        }
+    }
+    // Validate reason
+    if (!VALID_REASONS.includes(reason)) {
+        console.error(`Error: Invalid reason '${reason}'`);
+        console.error(`Valid reasons: ${VALID_REASONS.join(', ')}`);
+        process.exitCode = 1;
+        return;
+    }
+    // Resolve run ID (supports 'latest')
+    let runId;
+    try {
+        runId = resolveRunId(options.runId, repo);
+    }
+    catch (err) {
+        console.error(err.message);
+        process.exitCode = 1;
+        return;
+    }
+    // Get run store
+    const runStore = RunStore.init(runId, repo);
+    // Write intervention receipt
+    try {
+        const result = await writeIntervention({
+            runStorePath: runStore.path,
+            repoPath: repo,
+            runId,
+            reason,
+            note,
+            commands,
+            captureMode: cmdOutput,
+            redactSecrets: !noRedact,
+            sinceSha: since,
+            commitMessage: commit,
+            amendLast,
+            stageOnly,
+            workflowMode,
+            forceAmend: force
+        });
+        if (json) {
+            // JSON output for programmatic use
+            console.log(JSON.stringify({
+                success: true,
+                run_id: runId,
+                receipt_path: result.receiptPath,
+                trailers: result.trailers,
+                commands_run: result.receipt.commands.length,
+                all_passed: result.receipt.commands.every(c => c.exit_code === 0),
+                files_changed: result.receipt.files_changed.length
+            }, null, 2));
+        }
+        else {
+            // Human-readable output
+            printInterventionReceipt(result);
+        }
+    }
+    catch (err) {
+        console.error(`Error writing intervention: ${err.message}`);
+        process.exitCode = 1;
+    }
+}