@weldr/runr 0.3.1 → 0.7.2

package/dist/commands/doctor.js

@@ -1,6 +1,8 @@
 import { execa } from 'execa';
 import path from 'node:path';
-import { loadConfig, resolveConfigPath } from '../config/load.js';
+import fs from 'node:fs';
+import { resolveConfigPath, loadConfig } from '../config/load.js';
+import { getRunrPaths } from '../store/runs-root.js';
 async function checkWorker(name, worker, repoPath) {
     const result = {
         name,
@@ -61,64 +63,447 @@ async function checkWorker(name, worker, repoPath) {
     }
     return result;
 }
+/**
+ * Run worker health checks (used by run command)
+ * Only checks workers that are actually used by the phases config.
+ */
 export async function runDoctorChecks(config, repoPath) {
+    // Get unique workers that are actually used by phases
+    const usedWorkers = new Set([
+        config.phases.plan,
+        config.phases.implement,
+        config.phases.review
+    ]);
     const checks = [];
     for (const [name, workerConfig] of Object.entries(config.workers)) {
+        // Skip workers not used by any phase
+        if (!usedWorkers.has(name)) {
+            continue;
+        }
         const check = await checkWorker(name, workerConfig, repoPath);
         checks.push(check);
     }
     return checks;
 }
-export async function doctorCommand(options) {
-    const repoPath = path.resolve(options.repo || '.');
-    const configPath = resolveConfigPath(repoPath, options.config);
-    console.log('Doctor Check');
-    console.log('============\n');
-    let config;
+// ==========================================
+// Repository diagnostics (user-facing command)
+// ==========================================
+/**
+ * Check if the given path is inside a git repository
+ */
+async function checkGitRepository(repoPath) {
     try {
-        config = loadConfig(configPath);
-        console.log(`Config: ${configPath}`);
-        console.log(`Repo: ${repoPath}\n`);
+        const result = await execa('git', ['rev-parse', '--git-dir'], {
+            cwd: repoPath,
+            reject: false
+        });
+        if (result.exitCode === 0) {
+            return { ok: true };
+        }
+        else {
+            return { ok: false, error: 'not a git repository' };
+        }
     }
     catch (err) {
-        console.log(`Config: FAIL - ${err.message}`);
-        process.exitCode = 1;
-        return;
-    }
-    const checks = await runDoctorChecks(config, repoPath);
-    console.log('Workers\n-------');
-    for (const check of checks) {
-        const status = check.error ? 'FAIL' : 'PASS';
-        const version = check.version || 'unknown';
-        const headless = check.headless ? 'headless OK' : 'headless FAIL';
-        console.log(`${check.name}: ${status}`);
-        console.log(`  bin: ${check.bin}`);
-        console.log(`  version: ${version}`);
-        console.log(`  ${headless}`);
-        if (check.error) {
-            console.log(`  error: ${check.error}`);
-        }
-        console.log('');
-    }
-    // Show phase configuration
-    console.log('Phases\n------');
-    console.log(`  plan: ${config.phases.plan}`);
-    console.log(`  implement: ${config.phases.implement}`);
-    console.log(`  review: ${config.phases.review}`);
-    console.log('');
-    // Check that configured phase workers are available
-    const phaseWorkers = new Set([config.phases.plan, config.phases.implement, config.phases.review]);
-    const failedWorkers = checks.filter((c) => c.error).map((c) => c.name);
-    const usedButFailed = [...phaseWorkers].filter((w) => failedWorkers.includes(w));
-    const failed = checks.filter((c) => c.error);
-    if (failed.length > 0) {
-        console.log(`\nResult: ${failed.length} worker(s) failed`);
-        if (usedButFailed.length > 0) {
-            console.log(`Warning: Phase(s) configured to use failed worker(s): ${usedButFailed.join(', ')}`);
+        return { ok: false, error: `Git check failed: ${err.message}` };
+    }
+}
+/**
+ * Check working tree status
+ */
+async function checkWorkingTree(repoPath) {
+    try {
+        // Check for uncommitted changes
+        const statusResult = await execa('git', ['status', '--porcelain'], {
+            cwd: repoPath,
+            reject: false
+        });
+        if (statusResult.exitCode !== 0) {
+            return { ok: false, clean: false, error: 'git status failed' };
+        }
+        const uncommittedLines = statusResult.stdout.trim().split('\n').filter(line => line.length > 0);
+        const uncommittedCount = uncommittedLines.length;
+        const isClean = uncommittedCount === 0;
+        // Check for ignored noise
+        const ignoredResult = await execa('git', ['status', '--porcelain', '--ignored', '--', '.runr/', '.agent/', '.runr-worktrees/', '.agent-worktrees/'], { cwd: repoPath, reject: false });
+        const ignoredLines = ignoredResult.exitCode === 0
+            ? ignoredResult.stdout.trim().split('\n').filter(line => line.startsWith('!!')).length
+            : 0;
+        return {
+            ok: true,
+            clean: isClean,
+            uncommittedCount,
+            ignoredCount: ignoredLines
+        };
+    }
+    catch (err) {
+        return { ok: false, clean: false, error: `Working tree check failed: ${err.message}` };
+    }
+}
+/**
+ * Check if .runr/ is properly gitignored
+ * Uses git check-ignore if available, falls back to .gitignore parsing
+ */
+async function checkGitignore(repoPath) {
+    // Preferred method: use git check-ignore
+    try {
+        const result = await execa('git', ['check-ignore', '-q', '.runr/'], {
+            cwd: repoPath,
+            reject: false
+        });
+        // Exit code 0 means the path is ignored
+        if (result.exitCode === 0) {
+            return { ok: true, message: '.runr/ is gitignored ✓' };
+        }
+        // Exit code 1 means the path is not ignored
+        if (result.exitCode === 1) {
+            return {
+                ok: false,
+                message: '.runr/ is NOT gitignored - will cause dirty tree warnings\n' +
+                    '  Add ".runr/" to .gitignore or run "runr init" to update'
+            };
         }
+    }
+    catch {
+        // Git not available or other error, fall back to .gitignore parsing
+    }
+    // Fallback method: parse .gitignore file
+    const gitignorePath = path.join(repoPath, '.gitignore');
+    try {
+        const content = fs.readFileSync(gitignorePath, 'utf-8');
+        const lines = content.split('\n').map(l => l.trim());
+        const hasEntry = lines.some(line => line === '.runr/' ||
+            line === '.runr' ||
+            line.startsWith('.runr/'));
+        if (hasEntry) {
+            return { ok: true, message: '.runr/ is gitignored ✓' };
+        }
+        else {
+            return {
+                ok: false,
+                message: '.runr/ is NOT gitignored - will cause dirty tree warnings\n' +
+                    '  Add ".runr/" to .gitignore or run "runr init" to update'
+            };
+        }
+    }
+    catch {
+        return {
+            ok: false,
+            message: 'No .gitignore found - create one with ".runr/" entry'
+        };
+    }
+}
+/**
+ * Get version from package.json
+ */
+function getRunrVersion() {
+    try {
+        // Navigate up from dist/commands/doctor.js to find package.json
+        const packagePath = path.resolve(new URL(import.meta.url).pathname, '../../../package.json');
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf-8'));
+        return packageJson.version || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Check for config file and validate if present
+ */
+function checkConfig(repoPath, configPath) {
+    try {
+        const resolvedPath = resolveConfigPath(repoPath, configPath);
+        if (!fs.existsSync(resolvedPath)) {
+            return { ok: true, found: false };
+        }
+        // Try to load and validate config
+        try {
+            loadConfig(resolvedPath);
+            return { ok: true, found: true, path: resolvedPath, valid: true };
+        }
+        catch (err) {
+            return {
+                ok: false,
+                found: true,
+                path: resolvedPath,
+                valid: false,
+                error: `Invalid config: ${err.message}`
+            };
+        }
+    }
+    catch (err) {
+        return { ok: false, found: false, error: `Config check failed: ${err.message}` };
+    }
+}
+/**
+ * Check .runr/ directory write access
+ */
+async function checkRunrDirectory(repoPath) {
+    try {
+        const paths = getRunrPaths(repoPath);
+        const runrRoot = paths.runr_root;
+        if (!fs.existsSync(runrRoot)) {
+            return { ok: true, exists: false };
+        }
+        // Test write access
+        const testFile = path.join(runrRoot, '.doctor-test-write');
+        try {
+            fs.writeFileSync(testFile, 'test', 'utf-8');
+            fs.unlinkSync(testFile);
+        }
+        catch (err) {
+            return {
+                ok: false,
+                exists: true,
+                writable: false,
+                error: `Not writable: ${err.message}`
+            };
+        }
+        // Count runs if runs directory exists
+        let runCount = 0;
+        if (fs.existsSync(paths.runs_dir)) {
+            try {
+                const entries = fs.readdirSync(paths.runs_dir);
+                runCount = entries.filter(entry => {
+                    const fullPath = path.join(paths.runs_dir, entry);
+                    return fs.statSync(fullPath).isDirectory();
+                }).length;
+            }
+            catch {
+                // Ignore error counting runs
+            }
+        }
+        return { ok: true, exists: true, writable: true, runCount };
+    }
+    catch (err) {
+        return { ok: false, exists: false, error: `Directory check failed: ${err.message}` };
+    }
+}
+/**
+ * Check if AGENTS.md exists (for meta-agent workflows)
+ */
+function checkAgentsMd(repoPath) {
+    const agentsMdPath = path.join(repoPath, 'AGENTS.md');
+    return {
+        exists: fs.existsSync(agentsMdPath),
+        path: agentsMdPath
+    };
+}
+/**
+ * Check Claude Code integration status
+ */
+function checkClaudeIntegration(repoPath) {
+    const claudeDir = path.join(repoPath, '.claude');
+    const skillPath = path.join(repoPath, '.claude/skills/runr-workflow/SKILL.md');
+    const commandPaths = [
+        path.join(repoPath, '.claude/commands/runr-bundle.md'),
+        path.join(repoPath, '.claude/commands/runr-submit.md'),
+        path.join(repoPath, '.claude/commands/runr-resume.md')
+    ];
+    const claudeDetected = fs.existsSync(claudeDir);
+    const skillsPresent = fs.existsSync(skillPath);
+    const commandsPresent = commandPaths.every(p => fs.existsSync(p));
+    const missingFiles = [];
+    if (claudeDetected) {
+        if (!skillsPresent)
+            missingFiles.push('.claude/skills/runr-workflow/SKILL.md');
+        commandPaths.forEach(p => {
+            if (!fs.existsSync(p)) {
+                missingFiles.push(path.relative(repoPath, p));
+            }
+        });
+    }
+    return {
+        claudeDetected,
+        skillsPresent,
+        commandsPresent,
+        missingFiles: missingFiles.length > 0 ? missingFiles : undefined
+    };
+}
+/**
+ * Check worktree sanity
+ */
+async function checkWorktrees(repoPath) {
+    try {
+        const paths = getRunrPaths(repoPath);
+        const worktreesDir = paths.worktrees_dir;
+        if (!fs.existsSync(worktreesDir)) {
+            return { ok: true, worktreesUsed: false };
+        }
+        // List all worktree directories
+        const entries = fs.readdirSync(worktreesDir);
+        const worktreeDirs = entries.filter(entry => {
+            const fullPath = path.join(worktreesDir, entry);
+            return fs.statSync(fullPath).isDirectory();
+        });
+        if (worktreeDirs.length === 0) {
+            return { ok: true, worktreesUsed: false };
+        }
+        // Check which worktrees are still valid git worktrees
+        let orphanedCount = 0;
+        for (const dir of worktreeDirs) {
+            const worktreePath = path.join(worktreesDir, dir);
+            // Check if it's a valid git worktree
+            // A worktree must have .git file (not directory) pointing to parent repo
+            const gitPath = path.join(worktreePath, '.git');
+            const isValidWorktree = fs.existsSync(gitPath) && fs.statSync(gitPath).isFile();
+            if (!isValidWorktree) {
+                orphanedCount++;
+                continue;
+            }
+            // Double-check with git command
+            try {
+                const result = await execa('git', ['rev-parse', '--git-dir'], {
+                    cwd: worktreePath,
+                    reject: false
+                });
+                if (result.exitCode !== 0) {
+                    orphanedCount++;
+                }
+            }
+            catch {
+                orphanedCount++;
+            }
+        }
+        return {
+            ok: orphanedCount === 0,
+            worktreesUsed: true,
+            totalWorktrees: worktreeDirs.length,
+            orphanedWorktrees: orphanedCount
+        };
+    }
+    catch (err) {
+        return { ok: false, worktreesUsed: false, error: `Worktree check failed: ${err.message}` };
+    }
+}
+/**
+ * Run diagnostic checks on the repository
+ */
+export async function doctorCommand(options) {
+    const repoPath = path.resolve(options.repo || '.');
+    console.log('Runr Doctor');
+    console.log('===========\n');
+    let hasErrors = false;
+    // Check 1: Runr version
+    const version = getRunrVersion();
+    console.log(`Runr version: ${version}`);
+    // Check 2: Git repository
+    const gitCheck = await checkGitRepository(repoPath);
+    if (gitCheck.ok) {
+        console.log('Git repository: OK');
+    }
+    else {
+        console.log(`Git repository: FAIL - ${gitCheck.error}`);
+        hasErrors = true;
+    }
+    // Check 3: Working tree status
+    const treeCheck = await checkWorkingTree(repoPath);
+    if (treeCheck.ok) {
+        if (treeCheck.clean) {
+            console.log('Working tree: clean');
+        }
+        else {
+            console.log(`Working tree: dirty (${treeCheck.uncommittedCount} uncommitted files)`);
+            if (treeCheck.ignoredCount && treeCheck.ignoredCount > 0) {
+                console.log(`  Ignored noise: ${treeCheck.ignoredCount} files in .runr/`);
+            }
+            console.log('\n⚠️  Meta-Agent Safety Warning:');
+            console.log('   Never run agents on uncommitted work - you risk data loss.');
+            console.log('   Commit or stash before using `runr meta` or `runr run`.');
+        }
+    }
+    else {
+        console.log(`Working tree: FAIL - ${treeCheck.error}`);
+        hasErrors = true;
+    }
+    // Check 4: .gitignore
+    const gitignoreCheck = await checkGitignore(repoPath);
+    if (gitignoreCheck.ok) {
+        console.log(gitignoreCheck.message);
+    }
+    else {
+        console.log(`⚠ ${gitignoreCheck.message}`);
+    }
+    // Check 5: Config file
+    const configCheck = checkConfig(repoPath, options.config);
+    if (configCheck.found) {
+        if (configCheck.valid) {
+            console.log(`Config: ${configCheck.path}`);
+        }
+        else {
+            console.log(`Config: FAIL - ${configCheck.error}`);
+            hasErrors = true;
+        }
+    }
+    else {
+        console.log('Config: no config file (using defaults)');
+    }
+    // Check 6: .runr/ directory
+    const dirCheck = await checkRunrDirectory(repoPath);
+    if (dirCheck.exists) {
+        if (dirCheck.writable) {
+            const runInfo = dirCheck.runCount !== undefined ? ` (${dirCheck.runCount} runs)` : '';
+            console.log(`.runr/ directory: OK${runInfo}`);
+        }
+        else {
+            console.log(`.runr/ directory: FAIL - ${dirCheck.error}`);
+            hasErrors = true;
+        }
+    }
+    else {
+        console.log('.runr/ directory: not yet created');
+    }
+    // Check 7: Worktrees
+    const worktreeCheck = await checkWorktrees(repoPath);
+    if (worktreeCheck.worktreesUsed) {
+        if (worktreeCheck.ok) {
+            console.log(`Worktrees: OK (${worktreeCheck.totalWorktrees} worktrees)`);
+        }
+        else {
+            console.log(`Worktrees: WARNING - ${worktreeCheck.orphanedWorktrees} orphaned worktrees`);
+            console.log('  Run "runr tools gc" to clean up orphaned worktrees');
+            // Note: This is a warning, not an error - don't set hasErrors
+        }
+    }
+    else {
+        console.log('Worktrees: not used');
+    }
+    // Check 8: AGENTS.md (for meta-agent workflows)
+    const agentsCheck = checkAgentsMd(repoPath);
+    if (agentsCheck.exists) {
+        console.log('AGENTS.md: present ✓');
+    }
+    else {
+        console.log('⚠️  AGENTS.md: missing');
+        console.log('   Run "runr init --pack solo" to create workflow documentation');
+    }
+    // Check 9: Claude Code integration (if .claude/ exists)
+    const claudeCheck = checkClaudeIntegration(repoPath);
+    if (claudeCheck.claudeDetected) {
+        if (claudeCheck.skillsPresent && claudeCheck.commandsPresent) {
+            console.log('Claude Code integration: complete ✓');
+        }
+        else {
+            console.log('Claude Code integration: incomplete');
+            if (claudeCheck.missingFiles) {
+                console.log('  Missing:');
+                claudeCheck.missingFiles.forEach(file => console.log(`    - ${file}`));
+                console.log('  Run "runr init --pack solo --with-claude" to complete setup');
+            }
+        }
+    }
+    else {
+        console.log('Claude Code integration: not configured');
+        console.log('  (optional) Run "runr init --pack solo --with-claude" to add Claude Code support');
+    }
+    // Exit with appropriate code
+    console.log();
+    if (hasErrors) {
+        console.log('Result: Some checks failed');
         process.exitCode = 1;
     }
     else {
-        console.log('\nResult: All workers OK');
+        console.log('Result: All checks passed');
+        process.exitCode = 0;
     }
 }