skimpyclaw 0.3.6 → 0.3.9

package/dist/code-agents/executor.js

@@ -1,9 +1,10 @@
 // Code Agent Executor - Background execution logic
-import { spawn, exec } from 'child_process';
+import { spawn, exec, execSync } from 'child_process';
 import { createWriteStream, existsSync, readFileSync } from 'fs';
 import { join } from 'path';
 // SKIMPYCLAW_ROOT for log paths
 const SKIMPYCLAW_ROOT = join(import.meta.dirname || process.cwd(), '..', '..');
+import { toErrorMessage } from '../utils.js';
 import { VALIDATE_TIMEOUT_MS } from './types.js';
 import { getCodeAgentsDir, ensureCodeAgentsDir, writeCodeAgentTask, setCodeAgentCanceller, deleteCodeAgentCanceller, getCodeAgent, } from './registry.js';
 import { buildCodeAgentArgs, notifyCodeAgentResult } from './utils.js';
@@ -51,15 +52,184 @@ export function detectPackageManager(workdir) {
     // 3. Fallback
     return 'pnpm';
 }
+/**
+ * Detect monorepo workspaces from package.json.
+ * Returns workspace glob patterns or null if not a monorepo.
+ */
+function getWorkspacePatterns(workdir) {
+    try {
+        const pkgPath = join(workdir, 'package.json');
+        if (!existsSync(pkgPath))
+            return null;
+        const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+        // yarn/npm: "workspaces": ["packages/*"] or "workspaces": { "packages": [...] }
+        const ws = pkg.workspaces;
+        if (Array.isArray(ws))
+            return ws;
+        if (ws && Array.isArray(ws.packages))
+            return ws.packages;
+        // pnpm: check pnpm-workspace.yaml
+        const pnpmWsPath = join(workdir, 'pnpm-workspace.yaml');
+        if (existsSync(pnpmWsPath)) {
+            const content = readFileSync(pnpmWsPath, 'utf-8');
+            const matches = content.match(/- ['"]?([^'"\n]+)['"]?/g);
+            if (matches)
+                return matches.map(m => m.replace(/^- ['"]?|['"]?$/g, ''));
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find which monorepo packages have changed files (git diff).
+ * Returns package directories relative to workdir.
+ */
+function getChangedPackageDirs(workdir) {
+    try {
+        // Get changed files vs HEAD (staged + unstaged + untracked)
+        const diff = execSync('git diff --name-only HEAD 2>/dev/null; git diff --name-only --cached 2>/dev/null; git ls-files --others --exclude-standard 2>/dev/null', { cwd: workdir, timeout: 5000, encoding: 'utf-8' }).trim();
+        if (!diff)
+            return [];
+        const files = [...new Set(diff.split('\n').filter(Boolean))];
+        // Extract unique top-level package directories (e.g. "packages/image-studio/src/foo.ts" → "packages/image-studio")
+        const pkgDirs = new Set();
+        for (const f of files) {
+            const parts = f.split('/');
+            // Look for package.json at each depth to find package boundary
+            for (let depth = 1; depth <= Math.min(parts.length - 1, 4); depth++) {
+                const candidate = parts.slice(0, depth).join('/');
+                if (existsSync(join(workdir, candidate, 'package.json'))) {
+                    pkgDirs.add(candidate);
+                    break;
+                }
+            }
+        }
+        return [...pkgDirs];
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Build scoped validation commands for a monorepo by detecting changed packages.
+ * Returns a combined command that builds/tests only affected packages, or null
+ * if this doesn't look like a monorepo or no packages were changed.
+ */
+function buildMonorepoValidationCommand(workdir) {
+    const wsPatterns = getWorkspacePatterns(workdir);
+    if (!wsPatterns)
+        return null;
+    const changedDirs = getChangedPackageDirs(workdir);
+    if (changedDirs.length === 0)
+        return null;
+    const pm = detectPackageManager(workdir);
+    const parts = [];
+    for (const dir of changedDirs) {
+        const pkgJsonPath = join(workdir, dir, 'package.json');
+        if (!existsSync(pkgJsonPath))
+            continue;
+        try {
+            const pkg = JSON.parse(readFileSync(pkgJsonPath, 'utf-8'));
+            const pkgName = pkg.name;
+            const scripts = pkg.scripts || {};
+            if (!pkgName)
+                continue;
+            // Build with workspace command
+            if (scripts.build) {
+                if (pm === 'pnpm')
+                    parts.push(`pnpm --filter ${pkgName} run build`);
+                else if (pm === 'yarn')
+                    parts.push(`yarn workspace ${pkgName} build`);
+                else if (pm === 'bun')
+                    parts.push(`bun --filter ${pkgName} run build`);
+                else
+                    parts.push(`npm -w ${pkgName} run build`);
+            }
+            // Test: prefer package-scoped test, fall back to root test runner scoped to path
+            if (scripts.test) {
+                if (pm === 'pnpm')
+                    parts.push(`pnpm --filter ${pkgName} run test`);
+                else if (pm === 'yarn')
+                    parts.push(`yarn workspace ${pkgName} test`);
+                else if (pm === 'bun')
+                    parts.push(`bun --filter ${pkgName} run test`);
+                else
+                    parts.push(`npm -w ${pkgName} run test`);
+            }
+            else {
+                // No package-level test script — try running root test scoped to the package path
+                // This handles monorepos like wp-calypso with `jest --testPathPattern`
+                const rootPkg = JSON.parse(readFileSync(join(workdir, 'package.json'), 'utf-8'));
+                const rootScripts = rootPkg.scripts || {};
+                // Check for common monorepo test patterns
+                if (rootScripts['test-packages']) {
+                    if (pm === 'yarn')
+                        parts.push(`yarn test-packages ${dir}`);
+                    else
+                        parts.push(`${pm} run test-packages ${dir}`);
+                }
+            }
+        }
+        catch { /* skip this package */ }
+    }
+    if (parts.length === 0)
+        return null;
+    console.log(`[validation] Monorepo: scoped to ${changedDirs.length} package(s): ${changedDirs.join(', ')}`);
+    return parts.join(' && ');
+}
+/**
+ * Walk up from a directory to find a monorepo root (directory with workspaces).
+ * Returns the root path or null if not inside a monorepo.
+ */
+function findMonorepoRoot(startDir) {
+    let dir = startDir;
+    const root = '/';
+    while (dir !== root) {
+        if (getWorkspacePatterns(dir))
+            return dir;
+        const parent = join(dir, '..');
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
 /**
  * Build the validation command for a project directory.
- * Checks for `build` and `test` scripts in package.json, then runs them
- * with the detected package manager. Falls back to `<pm> build && <pm> test`.
+ *
+ * Resolution order:
+ * 1. Per-project override from config `codeAgents.validationCommands`
+ * 2. Monorepo auto-detection: scope to changed packages only
+ *    - Works both when workdir is the repo root AND when it's a package subdir
+ * 3. Auto-detect from package.json scripts (build + test)
+ * 4. Empty string (skip validation) if no scripts found
  */
-export function buildValidationCommand(workdir) {
+export function buildValidationCommand(workdir, validationCommands) {
+    // 1. Check per-project overrides
+    if (validationCommands) {
+        const dirName = workdir.split('/').pop() || '';
+        for (const [key, cmd] of Object.entries(validationCommands)) {
+            if (key === dirName || workdir === key || workdir.endsWith(`/${key}`)) {
+                return cmd;
+            }
+        }
+    }
+    // 2. Monorepo auto-detection — check workdir and parent dirs
+    const monorepoCmd = buildMonorepoValidationCommand(workdir);
+    if (monorepoCmd)
+        return monorepoCmd;
+    // Also check if workdir is a subpackage inside a monorepo
+    const monorepoRoot = findMonorepoRoot(workdir);
+    if (monorepoRoot && monorepoRoot !== workdir) {
+        const rootCmd = buildMonorepoValidationCommand(monorepoRoot);
+        if (rootCmd)
+            return rootCmd;
+    }
+    // 3. Simple project — use root package.json scripts
     const pm = detectPackageManager(workdir);
     const run = pm === 'npm' ? 'npm run' : pm;
-    // Check which scripts exist in package.json
     let hasBuild = false;
     let hasTest = false;
     try {
@@ -77,19 +247,23 @@ export function buildValidationCommand(workdir) {
         parts.push(`${run} build`);
     if (hasTest)
         parts.push(`${run} test`);
-    // If neither build nor test scripts exist, still try — the scripts
-    // might be defined in a workspace root or the commands may work anyway
     if (parts.length === 0) {
-        parts.push(`${run} build`, `${run} test`);
+        return '';
     }
     return parts.join(' && ');
 }
 /** Run build/test validation. Shared by solo agents and team orchestrator. */
-export function runValidation(workdir) {
-    const cmd = buildValidationCommand(workdir);
+export function runValidation(workdir, validationCommands) {
+    const cmd = buildValidationCommand(workdir, validationCommands);
+    if (!cmd) {
+        // No build/test scripts found — nothing to validate, pass by default
+        return Promise.resolve({ passed: true, output: 'PASS (no build/test scripts found)' });
+    }
+    // If workdir is inside a monorepo, run from the repo root so workspace commands work
+    const execDir = findMonorepoRoot(workdir) || workdir;
     return new Promise((resolve) => {
         exec(cmd, {
-            cwd: workdir,
+            cwd: execDir,
             timeout: VALIDATE_TIMEOUT_MS,
             maxBuffer: 5 * 1024 * 1024,
         }, (error, vStdout, vStderr) => {
@@ -315,7 +489,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             caTask.outputPreview = agentOutput.slice(0, 500);
             caTask.liveOutput = undefined;
             writeCodeAgentTask(caTask);
-            const validationCmd = buildValidationCommand(workdir);
+            const validationCmd = buildValidationCommand(workdir, options?.validationCommands);
             const runValidationPromise = () => new Promise((res) => {
                 const validationProc = exec(validationCmd, {
                     cwd: workdir,
@@ -521,7 +695,7 @@ export async function runCodeAgentBackground(id, agent, task, workdir, validate,
             await notifyCodeAgentResult(caTask, (id) => getCodeAgent(id) ?? null);
     }
     catch (err) {
-        const errMsg = err instanceof Error ? err.message : String(err);
+        const errMsg = toErrorMessage(err);
         addEvent(traceId, { type: 'error', summary: errMsg.slice(0, 200), durationMs: Date.now() - startedAt.getTime() });
         await endTrace(traceId, 'error');
         Object.assign(caTask, {

package/dist/code-agents/index.d.ts

@@ -4,7 +4,7 @@ export type { CodeAgentTask, DecomposedSubtask, CodeAgentBackgroundOptions, Buil
 export { CODE_AGENT_TIMEOUT_MS, VALIDATE_TIMEOUT_MS } from './types.js';
 export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgent, cancelCodeAgent, restoreCodeAgentTasks, getCodeAgentsDir, } from './registry.js';
 export { runCodeAgentBackground, runValidation } from './executor.js';
-export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, } from './orchestrator.js';
+export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, gatherCodebaseContext, } from './orchestrator.js';
 export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, readTeamState, } from './utils.js';
 export { parseStreamJsonForLive, parseClaudeOutput, parseCodexOutput } from './parser.js';
 export type { ClaudeOutputResult } from './parser.js';

package/dist/code-agents/index.js

@@ -5,7 +5,7 @@ import { isPathAllowed } from '../tools/path-utils.js';
 import { getNextCodeAgentId, storeCodeAgentTask, writeCodeAgentTask, getActiveCodeAgents, getRecentCodeAgents, getCodeAgent, } from './registry.js';
 import { runCodeAgentBackground } from './executor.js';
 import { runTeamOrchestrator } from './orchestrator.js';
-import { resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, } from './utils.js';
+import { resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, getCodingCliPreflightError, } from './utils.js';
 // Re-export timeout constants
 export { CODE_AGENT_TIMEOUT_MS, VALIDATE_TIMEOUT_MS } from './types.js';
 // Re-export registry functions
@@ -13,7 +13,7 @@ export { getActiveCodeAgents, getRecentCodeAgents, getAllCodeAgents, getCodeAgen
 // Re-export executor functions
 export { runCodeAgentBackground, runValidation } from './executor.js';
 // Re-export orchestrator functions
-export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, } from './orchestrator.js';
+export { runTeamOrchestrator, computeWaves, decomposeTask, synthesizeResults, gatherCodebaseContext, } from './orchestrator.js';
 // Re-export utility functions
 export { setCodeAgentConfig, getCodeAgentConfig, buildCodeAgentArgs, resolveSelectedCodeAgent, resolveWorkdir, resolveModelAlias, readTeamState, } from './utils.js';
 // Re-export parser functions
@@ -80,7 +80,7 @@ export async function executeCodeWithAgent(input, config, context) {
         catch { /* gateway not running */ }
     }
     const resolvedModel = resolveModelAlias(rawModel, context?.fullConfig?.models?.aliases);
-    const configDefault = context?.fullConfig?.subagents?.defaultCodeAgent || 'claude';
+    const configDefault = context?.fullConfig?.codeAgents?.defaultAgent || 'claude';
     const requestedAgent = input.agent;
     const agent = resolveSelectedCodeAgent(requestedAgent, configDefault, resolvedModel);
     if (!agent) {
@@ -99,12 +99,15 @@ export async function executeCodeWithAgent(input, config, context) {
             : '';
         return `Error: Working directory not allowed. Permitted: ${config.allowedPaths.join(', ')}${projectNames}`;
     }
-    // Concurrency check — share limit with subagents
-    const maxConcurrent = context?.fullConfig?.subagents?.maxConcurrent ?? 5;
+    // Concurrency check
+    const maxConcurrent = context?.fullConfig?.codeAgents?.maxConcurrent ?? 5;
     const activeCount = getActiveCodeAgents().length;
     if (activeCount >= maxConcurrent) {
-        return `Error: Concurrency limit reached (${activeCount}/${maxConcurrent} coding agents running). Wait for one to finish or increase subagents.maxConcurrent.`;
+        return `Error: Concurrency limit reached (${activeCount}/${maxConcurrent} coding agents running). Wait for one to finish or increase codeAgents.maxConcurrent.`;
     }
+    const cliPreflightError = getCodingCliPreflightError();
+    if (cliPreflightError)
+        return cliPreflightError;
     const validate = input.validate !== false; // default true
     // Create task with unique ID
     const id = getNextCodeAgentId();
@@ -122,8 +125,14 @@ export async function executeCodeWithAgent(input, config, context) {
     storeCodeAgentTask(caTask);
     writeCodeAgentTask(caTask);
     // Fire-and-forget: spawn background process
-    const resolvedInput = { ...input, model: resolvedModel };
-    runCodeAgentBackground(id, agent, task, workdir, validate, resolvedInput, startedAt).catch((err) => {
+    const configTimeout = context?.fullConfig?.codeAgents?.timeoutMinutes ?? 30;
+    const soloTimeout = Math.min(input.timeout_minutes || configTimeout, 60);
+    const resolvedInput = { ...input, model: resolvedModel, timeout_minutes: soloTimeout };
+    runCodeAgentBackground(id, agent, task, workdir, validate, resolvedInput, startedAt, {
+        defaultTimeoutMinutes: soloTimeout,
+        maxTimeoutMinutes: 60,
+        validationCommands: context?.fullConfig?.codeAgents?.validationCommands,
+    }).catch((err) => {
         console.error(`[code-agent] Background error for ${id}:`, err);
     });
     const taskPreview = task.length > 100 ? task.slice(0, 100) + '...' : task;
@@ -136,18 +145,14 @@ export async function executeCodeWithTeam(input, config, context) {
     const task = input.task;
     if (!task)
         return 'Error: task is required';
-    // Resolve model alias first so agent auto-selection can inspect it.
-    // Fall back to current session model so codex/kimi models auto-select the right CLI.
-    let rawTeamModel = input.model;
-    if (!rawTeamModel) {
-        try {
-            const { getCurrentModel } = await import('../gateway.js');
-            rawTeamModel = getCurrentModel();
-        }
-        catch { /* gateway not running */ }
-    }
-    const resolvedModel = resolveModelAlias(rawTeamModel, context?.fullConfig?.models?.aliases);
-    const configDefault = context?.fullConfig?.subagents?.defaultCodeAgent || 'claude';
+    // Resolve model alias. Only fall back to session model when an explicit model
+    // was requested — otherwise the session model (e.g. gpt-5.3-codex) would
+    // override agent selection even when the user wants claude.
+    const rawTeamModel = input.model;
+    const resolvedModel = rawTeamModel
+        ? resolveModelAlias(rawTeamModel, context?.fullConfig?.models?.aliases)
+        : undefined;
+    const configDefault = context?.fullConfig?.codeAgents?.defaultAgent || 'claude';
     const requestedAgent = input.agent;
     const agent = resolveSelectedCodeAgent(requestedAgent, configDefault, resolvedModel);
     if (!agent) {
@@ -167,13 +172,16 @@ export async function executeCodeWithTeam(input, config, context) {
             : '';
         return `Error: Working directory not allowed. Permitted: ${config.allowedPaths.join(', ')}${projectNames}`;
     }
+    const validate = input.validate !== false;
     // Concurrency check — need room for teamSize children
-    const maxConcurrent = context?.fullConfig?.subagents?.maxConcurrent ?? 5;
+    const maxConcurrent = context?.fullConfig?.codeAgents?.maxConcurrent ?? 5;
     const activeCount = getActiveCodeAgents().length;
     if (activeCount + teamSize > maxConcurrent) {
         return `Error: Concurrency limit — need ${teamSize} slots but only ${maxConcurrent - activeCount} available (${activeCount}/${maxConcurrent} running). Wait for agents to finish.`;
     }
-    const validate = input.validate !== false;
+    const cliPreflightError = getCodingCliPreflightError();
+    if (cliPreflightError)
+        return cliPreflightError;
     // Create parent task
     const id = getNextCodeAgentId();
     const startedAt = new Date();

package/dist/code-agents/orchestrator.d.ts

@@ -7,16 +7,22 @@ import type { DecomposedSubtask, ChildResult } from './types.js';
  * Throws if there's a cycle in the dependency graph.
  */
 export declare function computeWaves(subtasks: DecomposedSubtask[]): number[][];
+/**
+ * Gather lightweight codebase context to improve task decomposition.
+ * Returns a short summary of the project structure (file tree, package.json scripts).
+ * Capped at ~2000 chars to keep the decomposition prompt small.
+ */
+export declare function gatherCodebaseContext(workdir: string): string;
 /**
  * Use a quick model call to decompose a complex task into N subtasks with optional dependency info.
  * Falls back to numbered subtask splitting on parse error.
  * Falls back to all-independent if dependency info is missing or invalid.
  */
-export declare function decomposeTask(task: string, teamSize: number, config: Config): Promise<DecomposedSubtask[]>;
+export declare function decomposeTask(task: string, teamSize: number, config: Config, workdir?: string): Promise<DecomposedSubtask[]>;
 /**
  * Use a quick model call to synthesize results from multiple subtask completions.
  */
-export declare function synthesizeResults(originalTask: string, results: ChildResult[], config: Config): Promise<string>;
+export declare function synthesizeResults(originalTask: string, results: ChildResult[], config: Config, workdir?: string): Promise<string>;
 /**
  * Team orchestrator — decomposes task, spawns parallel agents, monitors, synthesizes.
  */