skimpyclaw 0.3.8 → 0.3.9

package/dist/__tests__/code-agents-preflight.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/code-agents-preflight.test.js

@@ -0,0 +1,88 @@
+import { afterEach, describe, expect, it, vi } from 'vitest';
+const PRECHECK_ERROR = 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).';
+const toolConfig = {
+    enabled: true,
+    allowedPaths: [process.cwd()],
+    maxIterations: 5,
+    bashTimeout: 5000,
+};
+async function loadSubject(preflightError) {
+    vi.resetModules();
+    const runCodeAgentBackground = vi.fn().mockResolvedValue(undefined);
+    const runTeamOrchestrator = vi.fn().mockResolvedValue(undefined);
+    vi.doMock('../code-agents/utils.js', async () => {
+        const actual = await vi.importActual('../code-agents/utils.js');
+        return {
+            ...actual,
+            getCodingCliPreflightError: () => preflightError,
+        };
+    });
+    vi.doMock('../code-agents/executor.js', () => ({
+        runCodeAgentBackground,
+        runValidation: vi.fn(),
+        buildValidationCommand: vi.fn(() => 'pnpm build && pnpm test'),
+    }));
+    vi.doMock('../code-agents/orchestrator.js', () => ({
+        runTeamOrchestrator,
+        computeWaves: vi.fn(),
+        decomposeTask: vi.fn(),
+        synthesizeResults: vi.fn(),
+        gatherCodebaseContext: vi.fn(),
+    }));
+    vi.doMock('../code-agents/registry.js', () => ({
+        getNextCodeAgentId: vi.fn(() => 'ca_test_1'),
+        storeCodeAgentTask: vi.fn(),
+        writeCodeAgentTask: vi.fn(),
+        getActiveCodeAgents: vi.fn(() => []),
+        getRecentCodeAgents: vi.fn(() => []),
+        getAllCodeAgents: vi.fn(() => []),
+        getCodeAgent: vi.fn(() => null),
+        cancelCodeAgent: vi.fn(),
+        restoreCodeAgentTasks: vi.fn(),
+        getCodeAgentsDir: vi.fn(() => process.cwd()),
+    }));
+    const subject = await import('../code-agents/index.js');
+    return { ...subject, runCodeAgentBackground, runTeamOrchestrator };
+}
+afterEach(() => {
+    vi.doUnmock('../code-agents/utils.js');
+    vi.doUnmock('../code-agents/executor.js');
+    vi.doUnmock('../code-agents/orchestrator.js');
+    vi.doUnmock('../code-agents/registry.js');
+    vi.clearAllMocks();
+    vi.resetModules();
+});
+describe('coding CLI preflight guard', () => {
+    it('fails code_with_agent before spawning when no supported CLI is available', async () => {
+        const { executeCodeWithAgent, runCodeAgentBackground } = await loadSubject(PRECHECK_ERROR);
+        const result = await executeCodeWithAgent({ task: 'Fix bug', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toBe(PRECHECK_ERROR);
+        expect(runCodeAgentBackground).not.toHaveBeenCalled();
+    });
+    it('fails code_with_team before spawning when no supported CLI is available', async () => {
+        const { executeCodeWithTeam, runTeamOrchestrator } = await loadSubject(PRECHECK_ERROR);
+        const result = await executeCodeWithTeam({ task: 'Refactor auth', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toBe(PRECHECK_ERROR);
+        expect(runTeamOrchestrator).not.toHaveBeenCalled();
+    });
+    it('allows code_with_agent when at least one supported CLI exists', async () => {
+        const { executeCodeWithAgent, runCodeAgentBackground } = await loadSubject(null);
+        const result = await executeCodeWithAgent({ task: 'Fix bug', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toContain('Started coding agent');
+        expect(runCodeAgentBackground).toHaveBeenCalledTimes(1);
+    });
+    it('allows code_with_team when at least one supported CLI exists', async () => {
+        const { executeCodeWithTeam, runTeamOrchestrator } = await loadSubject(null);
+        const result = await executeCodeWithTeam({ task: 'Refactor auth', workdir: process.cwd() }, toolConfig, {
+            fullConfig: { codeAgents: { maxConcurrent: 99 } },
+        });
+        expect(result).toContain('Started coding team');
+        expect(runTeamOrchestrator).toHaveBeenCalledTimes(1);
+    });
+});

package/dist/__tests__/code-agents-utils.test.js

@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest';
-import { normalizeCodeAgent, resolveSelectedCodeAgent } from '../code-agents/utils.js';
+import { normalizeCodeAgent, resolveSelectedCodeAgent, getAvailableCodingCliTools, getCodingCliPreflightError, } from '../code-agents/utils.js';
 describe('normalizeCodeAgent', () => {
     it('accepts strict ids', () => {
         expect(normalizeCodeAgent('claude')).toBe('claude');
@@ -39,3 +39,14 @@ describe('resolveSelectedCodeAgent', () => {
         expect(resolveSelectedCodeAgent('claude', 'claude', 'gpt-4.1')).toBe('claude');
     });
 });
+describe('coding CLI preflight', () => {
+    it('returns a clear error when no supported CLI is found on PATH', () => {
+        expect(getAvailableCodingCliTools(() => false)).toEqual([]);
+        expect(getCodingCliPreflightError(() => false)).toBe('Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).');
+    });
+    it('accepts claude-code binary as claude support', () => {
+        const hasCommand = (name) => name === 'claude-code';
+        expect(getAvailableCodingCliTools(hasCommand)).toEqual(['claude']);
+        expect(getCodingCliPreflightError(hasCommand)).toBeNull();
+    });
+});

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
@@ -105,6 +105,9 @@ export async function executeCodeWithAgent(input, config, context) {
     if (activeCount >= 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();
@@ -176,6 +179,9 @@ export async function executeCodeWithTeam(input, config, context) {
     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 cliPreflightError = getCodingCliPreflightError();
+    if (cliPreflightError)
+        return cliPreflightError;
     // Create parent task
     const id = getNextCodeAgentId();
     const startedAt = new Date();

package/dist/code-agents/orchestrator.js

@@ -567,6 +567,27 @@ export async function runTeamOrchestrator(parentId, task, teamSize, workdir, val
         if (getCodeAgent(parentId)?.status === 'cancelled')
             throw new Error(CANCELLED_MESSAGE);
         parentTask.liveOutput = 'Phase: Synthesizing results...';
+        // Aggregate cost/tokens from all children into parent
+        let totalCost = 0;
+        let totalInput = 0;
+        let totalOutput = 0;
+        let hasCostData = false;
+        for (const cid of childIds) {
+            const child = getCodeAgent(cid);
+            if (child?.totalCost != null) {
+                totalCost += child.totalCost;
+                hasCostData = true;
+            }
+            if (child?.inputTokens != null)
+                totalInput += child.inputTokens;
+            if (child?.outputTokens != null)
+                totalOutput += child.outputTokens;
+        }
+        if (hasCostData) {
+            parentTask.totalCost = totalCost;
+            parentTask.inputTokens = totalInput;
+            parentTask.outputTokens = totalOutput;
+        }
         writeCodeAgentTask(parentTask);
         const childResults = childIds.map(id => {
             const child = getCodeAgent(id);

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

@@ -1,5 +1,9 @@
 import type { BuildCodeAgentArgsInput, CodeAgentTask } from './types.js';
 import type { Config } from '../types.js';
+/** Return supported coding CLIs currently available on PATH. */
+export declare function getAvailableCodingCliTools(commandChecker?: (name: string) => boolean): Array<'codex' | 'claude' | 'kimi'>;
+/** Return preflight error when no supported coding CLI is installed. */
+export declare function getCodingCliPreflightError(commandChecker?: (name: string) => boolean): string | null;
 /**
  * Normalize legacy/default agent values to supported CLI agent IDs.
  * Accepts strict IDs and older alias-like values (e.g. "claude-think").

package/dist/code-agents/utils.js

@@ -12,9 +12,35 @@ function resolveCliPath(name) {
         return name;
     }
 }
+function isCommandAvailable(name) {
+    try {
+        execSync(`command -v ${name}`, { stdio: 'ignore' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
 const CLAUDE_CLI_PATH = resolveCliPath('claude');
 const CODEX_CLI_PATH = resolveCliPath('codex');
 const KIMI_CLI_PATH = resolveCliPath('kimi');
+/** Return supported coding CLIs currently available on PATH. */
+export function getAvailableCodingCliTools(commandChecker = isCommandAvailable) {
+    const available = [];
+    if (commandChecker('codex'))
+        available.push('codex');
+    if (commandChecker('claude') || commandChecker('claude-code'))
+        available.push('claude');
+    if (commandChecker('kimi'))
+        available.push('kimi');
+    return available;
+}
+/** Return preflight error when no supported coding CLI is installed. */
+export function getCodingCliPreflightError(commandChecker = isCommandAvailable) {
+    if (getAvailableCodingCliTools(commandChecker).length > 0)
+        return null;
+    return 'Error: No supported coding CLI found on PATH. Install Codex CLI (`codex`), Claude Code CLI (`claude` or `claude-code`), or Kimi CLI (`kimi`).';
+}
 /**
  * Normalize legacy/default agent values to supported CLI agent IDs.
  * Accepts strict IDs and older alias-like values (e.g. "claude-think").

package/dist/setup.js

@@ -1085,10 +1085,8 @@ export async function runSetup(options = {}) {
         sectionHeader('Starter Packs (optional)');
         const localTz = Intl.DateTimeFormat().resolvedOptions().timeZone || 'UTC';
         const addTechNewsCron = /^y(es)?$/i.test(await ask(rl, '   Add starter cron: top 10 Hacker News daily? [y/N]: '));
-        const addWeatherCron = /^y(es)?$/i.test(await ask(rl, '   Add starter cron: weather check daily at 7:00am? [y/N]: '));
         let cronTimezone = localTz;
-        let weatherLocation = 'New York, NY';
-        if (addTechNewsCron || addWeatherCron) {
+        if (addTechNewsCron) {
             const tzInput = await ask(rl, `   Timezone for starter cron jobs [${localTz}]: `);
             cronTimezone = tzInput || localTz;
             try {
@@ -1099,21 +1097,15 @@ export async function runSetup(options = {}) {
                 cronTimezone = localTz;
             }
         }
-        if (addWeatherCron) {
-            const locationInput = await ask(rl, '   Weather location (city, state/country) [New York, NY]: ');
-            weatherLocation = locationInput || 'New York, NY';
-        }
         const addDailyNotesSkill = /^y(es)?$/i.test(await ask(rl, '   Add starter skill: daily-notes? [y/N]: '));
-        const addWeatherSkill = /^y(es)?$/i.test(await ask(rl, '   Add starter skill: weather? [y/N]: '));
-        const addWebSearchSkill = /^y(es)?$/i.test(await ask(rl, '   Add starter skill: web-search (uses Browser tool)? [y/N]: '));
         const starters = {
             cronTechNews: addTechNewsCron,
-            cronWeather: addWeatherCron,
+            cronWeather: false,
             timezone: cronTimezone,
-            weatherLocation,
+            weatherLocation: '',
             skillDailyNotes: addDailyNotesSkill,
-            skillWeather: addWeatherSkill,
-            skillWebSearch: addWebSearchSkill,
+            skillWeather: false,
+            skillWebSearch: false,
         };
         const { envContent, config: generatedConfig } = buildSetupArtifacts({
             workspaceDir: extraAllowedPaths[0] || join(homedir(), '.skimpyclaw'),
@@ -1320,6 +1312,11 @@ export async function runSetup(options = {}) {
         console.log('   skimpyclaw status');
         console.log(`${step++}. Optional daemon controls: skimpyclaw stop | skimpyclaw restart`);
         console.log(`${step++}. Send /help in your ${useDiscord ? 'Discord bot DM/server' : 'Telegram bot'}`);
+        console.log('');
+        console.log(`${c.yellow('Note:')} The /team and /code tools require an external coding CLI on your PATH:`);
+        console.log('   • Claude Code CLI  →  https://docs.anthropic.com/en/docs/claude-code');
+        console.log('   • Codex CLI        →  https://github.com/openai/codex');
+        console.log('   Install at least one to use code_with_agent / code_with_team.');
         console.log('\n👙🦞 Enjoy!');
     }
     finally {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "skimpyclaw",
-  "version": "0.3.8",
+  "version": "0.3.9",
   "description": "Lightweight personal AI assistant with Telegram and Discord integration",
   "type": "module",
   "main": "dist/index.js",
@@ -16,6 +16,25 @@
     "README.md",
     "LICENSE"
   ],
+  "scripts": {
+    "cli": "tsx src/cli.ts",
+    "start": "tsx src/index.ts",
+    "dev": "tsx watch src/index.ts",
+    "dashboard:dev": "pnpm --dir web/dashboard dev",
+    "dashboard:build": "pnpm --dir web/dashboard install --frozen-lockfile && pnpm --dir web/dashboard build",
+    "docs:dev": "pnpm --dir docs dev",
+    "docs:build": "pnpm --dir docs install --frozen-lockfile && pnpm --dir docs build",
+    "docs:preview": "pnpm --dir docs preview",
+    "setup": "tsx src/setup.ts",
+    "onboard": "tsx src/cli.ts onboard",
+    "build": "tsc && pnpm dashboard:build",
+    "release:check": "pnpm build && pnpm test",
+    "release:local": "bash ./scripts/release.sh",
+    "lint": "eslint \"src/**/*.ts\"",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "ci": "pnpm run lint && pnpm run typecheck && pnpm run test"
+  },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.52.0",
     "@grammyjs/runner": "^2.0.3",
@@ -37,6 +56,11 @@
     "openai": "^4.47.0",
     "playwright": "^1.49.0"
   },
+  "pnpm": {
+    "onlyBuiltDependencies": [
+      "esbuild"
+    ]
+  },
   "devDependencies": {
     "@eslint/js": "^9.39.2",
     "@types/node": "^20.11.0",
@@ -46,24 +70,5 @@
     "typescript": "^5.4.0",
     "typescript-eslint": "^8.54.0",
     "vitest": "^4.0.18"
-  },
-  "scripts": {
-    "cli": "tsx src/cli.ts",
-    "start": "tsx src/index.ts",
-    "dev": "tsx watch src/index.ts",
-    "dashboard:dev": "pnpm --dir web/dashboard dev",
-    "dashboard:build": "pnpm --dir web/dashboard install --frozen-lockfile && pnpm --dir web/dashboard build",
-    "docs:dev": "pnpm --dir docs dev",
-    "docs:build": "pnpm --dir docs install --frozen-lockfile && pnpm --dir docs build",
-    "docs:preview": "pnpm --dir docs preview",
-    "setup": "tsx src/setup.ts",
-    "onboard": "tsx src/cli.ts onboard",
-    "build": "tsc && pnpm dashboard:build",
-    "release:check": "pnpm build && pnpm test",
-    "release:local": "bash ./scripts/release.sh",
-    "lint": "eslint \"src/**/*.ts\"",
-    "typecheck": "tsc --noEmit",
-    "test": "vitest run",
-    "ci": "pnpm run lint && pnpm run typecheck && pnpm run test"
   }
-}
+}