icopilot 2.2.0

package/dist/agents/tdd-agent.js

@@ -0,0 +1,278 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+const FRAMEWORKS = {
+    vitest: {
+        name: 'vitest',
+        argsForFile: (testFile, cwd) => ['vitest', 'run', path.relative(cwd, testFile)],
+    },
+    jest: {
+        name: 'jest',
+        argsForFile: (testFile, cwd) => ['jest', '--runInBand', path.relative(cwd, testFile)],
+    },
+    mocha: {
+        name: 'mocha',
+        argsForFile: (testFile, cwd) => ['mocha', path.relative(cwd, testFile)],
+    },
+};
+export class TDDAgent {
+    cwd;
+    constructor(cwd = process.cwd()) {
+        this.cwd = cwd;
+    }
+    generateTests(spec) {
+        const normalized = normalizeSpec(spec);
+        const files = this.planFiles(normalized);
+        const framework = this.detectFramework();
+        const importPath = toImportPath(files.testFile, files.sourceFile);
+        const specLiteral = JSON.stringify(normalized, null, 2);
+        const suiteName = `${files.slug} tdd cycle`;
+        if (framework === 'jest') {
+            return [
+                "import { describe, it, expect } from '@jest/globals';",
+                `import { buildArtifact } from '${importPath}';`,
+                '',
+                `const spec = ${specLiteral} as const;`,
+                '',
+                `describe('${suiteName}', () => {`,
+                "  it('captures the original description', () => {",
+                '    expect(buildArtifact().description).toBe(spec.description);',
+                '  });',
+                '',
+                "  it('retains sample inputs', () => {",
+                '    expect(buildArtifact().inputExamples).toEqual(spec.inputExamples ?? []);',
+                '  });',
+                '',
+                '  for (const behavior of spec.expectedBehaviors) {',
+                '    it(`tracks behavior: ${behavior}`, () => {',
+                '      expect(buildArtifact().expectedBehaviors).toContain(behavior);',
+                '    });',
+                '  }',
+                '});',
+                '',
+                renderSpecComment(normalized),
+            ].join('\n');
+        }
+        if (framework === 'mocha') {
+            return [
+                "import assert from 'node:assert/strict';",
+                "import { describe, it } from 'mocha';",
+                `import { buildArtifact } from '${importPath}';`,
+                '',
+                `const spec = ${specLiteral} as const;`,
+                '',
+                `describe('${suiteName}', () => {`,
+                "  it('captures the original description', () => {",
+                '    assert.equal(buildArtifact().description, spec.description);',
+                '  });',
+                '',
+                "  it('retains sample inputs', () => {",
+                '    assert.deepEqual(buildArtifact().inputExamples, spec.inputExamples ?? []);',
+                '  });',
+                '',
+                '  for (const behavior of spec.expectedBehaviors) {',
+                '    it(`tracks behavior: ${behavior}`, () => {',
+                '      assert.equal(buildArtifact().expectedBehaviors.includes(behavior), true);',
+                '    });',
+                '  }',
+                '});',
+                '',
+                renderSpecComment(normalized),
+            ].join('\n');
+        }
+        return [
+            "import { describe, it, expect } from 'vitest';",
+            `import { buildArtifact } from '${importPath}';`,
+            '',
+            `const spec = ${specLiteral} as const;`,
+            '',
+            `describe('${suiteName}', () => {`,
+            "  it('captures the original description', () => {",
+            '    expect(buildArtifact().description).toBe(spec.description);',
+            '  });',
+            '',
+            "  it('retains sample inputs', () => {",
+            '    expect(buildArtifact().inputExamples).toEqual(spec.inputExamples ?? []);',
+            '  });',
+            '',
+            '  for (const behavior of spec.expectedBehaviors) {',
+            '    it(`tracks behavior: ${behavior}`, () => {',
+            '      expect(buildArtifact().expectedBehaviors).toContain(behavior);',
+            '    });',
+            '  }',
+            '});',
+            '',
+            renderSpecComment(normalized),
+        ].join('\n');
+    }
+    implement(testFile) {
+        const spec = this.readEmbeddedSpec(testFile);
+        const specLiteral = JSON.stringify(spec, null, 2);
+        return [
+            'export interface GeneratedTDDArtifact {',
+            '  description: string;',
+            '  inputExamples: string[];',
+            '  expectedBehaviors: string[];',
+            '}',
+            '',
+            `const artifact = ${specLiteral} as const;`,
+            '',
+            'export function buildArtifact(): GeneratedTDDArtifact {',
+            '  return {',
+            '    description: artifact.description,',
+            '    inputExamples: [...(artifact.inputExamples ?? [])],',
+            '    expectedBehaviors: [...artifact.expectedBehaviors],',
+            '  };',
+            '}',
+            '',
+            'export default buildArtifact;',
+            '',
+        ].join('\n');
+    }
+    runTests(testFile) {
+        const framework = FRAMEWORKS[this.detectFramework()];
+        const result = spawnSync('npx', framework.argsForFile(testFile, this.cwd), {
+            cwd: this.cwd,
+            encoding: 'utf8',
+            shell: process.platform === 'win32',
+        });
+        const output = `${result.stdout ?? ''}${result.stderr ?? ''}`.trim();
+        const passed = lastNumberMatch(output, /\b(\d+)\s+passed\b/gi);
+        const failed = lastNumberMatch(output, /\b(\d+)\s+failed\b/gi);
+        const total = lastNumberMatch(output, /\b(\d+)\s+total\b/gi) ||
+            lastNumberMatch(output, /Tests?\s+.*\((\d+)\)/gi) ||
+            passed + failed;
+        return {
+            passed: passed || (result.status === 0 ? total : 0),
+            failed: failed || (result.status === 0 ? 0 : total > 0 ? Math.max(total - passed, 1) : 1),
+            total: total || passed + failed || (result.status === 0 ? 1 : 1),
+            output,
+        };
+    }
+    refactor(src, _test) {
+        return `${src
+            .split(/\r?\n/)
+            .map((line) => line.trimEnd())
+            .join('\n')
+            .replace(/\n{3,}/g, '\n\n')
+            .trimEnd()}\n`;
+    }
+    fullCycle(spec) {
+        const normalized = normalizeSpec(spec);
+        const files = this.planFiles(normalized);
+        fs.mkdirSync(path.dirname(files.testFile), { recursive: true });
+        fs.mkdirSync(path.dirname(files.sourceFile), { recursive: true });
+        const testSource = this.generateTests(normalized);
+        fs.writeFileSync(files.testFile, testSource, 'utf8');
+        let cycles = 1;
+        const firstRun = this.runTests(files.testFile);
+        if (firstRun.failed > 0 || !fs.existsSync(files.sourceFile)) {
+            fs.writeFileSync(files.sourceFile, this.implement(files.testFile), 'utf8');
+            cycles += 1;
+        }
+        let finalRun = this.runTests(files.testFile);
+        if (finalRun.failed > 0) {
+            const currentSource = fs.readFileSync(files.sourceFile, 'utf8');
+            fs.writeFileSync(files.sourceFile, this.refactor(currentSource, testSource), 'utf8');
+            cycles += 1;
+            finalRun = this.runTests(files.testFile);
+        }
+        return {
+            spec: normalized,
+            testFile: files.testFile,
+            sourceFile: files.sourceFile,
+            cycles,
+            finalStatus: finalRun.failed === 0 ? 'green' : 'red',
+        };
+    }
+    detectFramework() {
+        const pkg = this.readPackageJson();
+        const testScript = String(pkg?.scripts?.test ?? '').toLowerCase();
+        if (testScript.includes('vitest') || this.hasConfigPrefix('vitest.config.'))
+            return 'vitest';
+        if (testScript.includes('jest') || this.hasConfigPrefix('jest.config.'))
+            return 'jest';
+        if (testScript.includes('mocha') || this.hasDependency(pkg, 'mocha'))
+            return 'mocha';
+        if (this.hasDependency(pkg, 'vitest'))
+            return 'vitest';
+        if (this.hasDependency(pkg, 'jest'))
+            return 'jest';
+        return 'vitest';
+    }
+    planFiles(spec) {
+        const slug = slugify(spec.description) || 'tdd-cycle';
+        return {
+            slug,
+            testFile: path.join(this.cwd, 'tests', 'tdd', `${slug}.test.ts`),
+            sourceFile: path.join(this.cwd, 'src', 'tdd', `${slug}.ts`),
+        };
+    }
+    readEmbeddedSpec(testFile) {
+        const testSource = fs.readFileSync(testFile, 'utf8');
+        const match = /\/\*\s*TDD_SPEC\s*([\s\S]*?)\*\//.exec(testSource);
+        if (!match?.[1]) {
+            throw new Error(`Missing embedded TDD spec in ${testFile}`);
+        }
+        return normalizeSpec(JSON.parse(match[1]));
+    }
+    readPackageJson() {
+        const packagePath = path.join(this.cwd, 'package.json');
+        if (!fs.existsSync(packagePath))
+            return undefined;
+        try {
+            return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+        }
+        catch {
+            return undefined;
+        }
+    }
+    hasDependency(pkg, name) {
+        return Boolean(pkg?.devDependencies?.[name] ?? pkg?.dependencies?.[name]);
+    }
+    hasConfigPrefix(prefix) {
+        try {
+            return fs.readdirSync(this.cwd).some((entry) => entry.startsWith(prefix));
+        }
+        catch {
+            return false;
+        }
+    }
+}
+function normalizeSpec(spec) {
+    const description = spec.description.trim();
+    const inputExamples = [
+        ...new Set((spec.inputExamples ?? []).map((item) => item.trim()).filter(Boolean)),
+    ];
+    const expectedBehaviors = [
+        ...new Set(spec.expectedBehaviors.map((item) => item.trim()).filter(Boolean)),
+    ];
+    return {
+        description,
+        ...(inputExamples.length > 0 ? { inputExamples } : {}),
+        expectedBehaviors: expectedBehaviors.length > 0 ? expectedBehaviors : ['captures the original description'],
+    };
+}
+function renderSpecComment(spec) {
+    return `/* TDD_SPEC\n${JSON.stringify(spec, null, 2)}\n*/`;
+}
+function toImportPath(fromFile, targetFile) {
+    const relative = path.relative(path.dirname(fromFile), targetFile).replace(/\\/g, '/');
+    const prefixed = relative.startsWith('.') ? relative : `./${relative}`;
+    return prefixed.replace(/\.(?:ts|tsx|js|jsx)$/i, '.js');
+}
+function slugify(value) {
+    return value
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+function lastNumberMatch(text, pattern) {
+    let match = null;
+    let last = 0;
+    while ((match = pattern.exec(text)) !== null) {
+        last = Number(match[1] ?? 0);
+    }
+    return Number.isFinite(last) ? last : 0;
+}

package/dist/api/github-models.js

@@ -0,0 +1,158 @@
+import OpenAI from 'openai';
+import { config } from '../config.js';
+import { providerRegistry, resolveProviderApiKey, } from '../providers/custom-provider.js';
+import { ProxyManager } from '../security/proxy.js';
+import { theme } from '../ui/theme.js';
+let _client = null;
+let _clientCacheKey = null;
+export function client() {
+    const provider = activeProvider();
+    const proxyConfig = ProxyManager.shared().loadConfig();
+    const cacheKey = JSON.stringify({
+        provider: config.provider,
+        endpoint: config.endpoint,
+        token: config.token || resolveProviderApiKey(provider) || 'not-needed',
+        headers: provider?.headers || null,
+        proxy: proxyConfig,
+    });
+    if (_client && _clientCacheKey === cacheKey)
+        return _client;
+    _client = new OpenAI({
+        apiKey: config.token || resolveProviderApiKey(provider) || 'not-needed',
+        baseURL: config.endpoint || provider?.baseUrl,
+        defaultHeaders: provider?.headers,
+        httpAgent: ProxyManager.shared().getAgent(),
+    });
+    _clientCacheKey = cacheKey;
+    return _client;
+}
+export function activeProvider() {
+    return providerRegistry.get(config.provider) || providerRegistry.getActive();
+}
+/**
+ * Stream a chat completion from GitHub Models, with exponential backoff
+ * on HTTP 429. Supports tool/function calling.
+ */
+export async function streamChat(opts) {
+    const maxAttempts = 5;
+    let attempt = 0;
+    let lastErr;
+    while (attempt < maxAttempts) {
+        try {
+            return await runOnce(opts);
+        }
+        catch (err) {
+            lastErr = err;
+            const status = err?.status ?? err?.response?.status;
+            if (err?.name === 'AbortError' || opts.signal?.aborted)
+                throw err;
+            if (status === 429) {
+                const retryAfter = Number(err?.headers?.get?.('retry-after') || err?.response?.headers?.['retry-after'] || 0);
+                const wait = retryAfter > 0 ? retryAfter * 1000 : 2 ** attempt * 1500;
+                process.stderr.write(theme.warn(`\n⚠  Rate limit (429). Cooling down ${Math.ceil(wait / 1000)}s ` +
+                    `(attempt ${attempt + 1}/${maxAttempts})…\n`));
+                await sleep(wait, opts.signal);
+                attempt++;
+                continue;
+            }
+            if (status && status >= 500 && status < 600 && attempt < maxAttempts - 1) {
+                const wait = 2 ** attempt * 1000;
+                process.stderr.write(theme.warn(`\n⚠  Upstream ${status}; retrying in ${wait}ms…\n`));
+                await sleep(wait, opts.signal);
+                attempt++;
+                continue;
+            }
+            throw err;
+        }
+    }
+    throw lastErr;
+}
+async function runOnce(opts) {
+    const provider = activeProvider();
+    const request = {
+        model: opts.model,
+        messages: opts.messages,
+        tools: opts.tools,
+        temperature: opts.temperature ?? 0.2,
+        ...buildChatReasoningParams(opts.model, provider?.maxTokens),
+        stream: true,
+    };
+    const stream = (await client().chat.completions.create(request, {
+        signal: opts.signal,
+    }));
+    let content = '';
+    let finishReason = null;
+    const toolAcc = {};
+    for await (const chunk of stream) {
+        const choice = chunk.choices?.[0];
+        if (!choice)
+            continue;
+        const delta = choice.delta || {};
+        if (typeof delta.content === 'string' && delta.content.length) {
+            content += delta.content;
+            opts.onToken(delta.content);
+        }
+        if (Array.isArray(delta.tool_calls)) {
+            for (const tc of delta.tool_calls) {
+                const idx = tc.index ?? 0;
+                const cur = toolAcc[idx] || (toolAcc[idx] = { id: '', name: '', arguments: '' });
+                if (tc.id)
+                    cur.id = tc.id;
+                if (tc.function?.name)
+                    cur.name = tc.function.name;
+                if (tc.function?.arguments)
+                    cur.arguments += tc.function.arguments;
+            }
+        }
+        if (choice.finish_reason)
+            finishReason = choice.finish_reason;
+    }
+    return {
+        content,
+        toolCalls: Object.values(toolAcc).filter((t) => t.name),
+        finishReason,
+    };
+}
+function buildChatReasoningParams(model, providerMaxTokens) {
+    const params = {};
+    if (supportsReasoningEffort(model) && config.reasoningEffort) {
+        params.reasoning_effort = config.reasoningEffort;
+    }
+    const completionBudget = resolveCompletionBudget(model, providerMaxTokens, config.thinkTokens);
+    if (completionBudget !== undefined) {
+        params.max_completion_tokens = completionBudget;
+        return params;
+    }
+    if (providerMaxTokens) {
+        params.max_tokens = providerMaxTokens;
+    }
+    return params;
+}
+function resolveCompletionBudget(model, providerMaxTokens, thinkTokens) {
+    if (!supportsReasoningTokenBudget(model))
+        return undefined;
+    const budgets = [providerMaxTokens, thinkTokens].filter((value) => typeof value === 'number' && Number.isFinite(value) && value >= 0);
+    if (!budgets.length)
+        return undefined;
+    return Math.min(...budgets.map((value) => Math.floor(value)));
+}
+function supportsReasoningEffort(model) {
+    return /^o\d/i.test(model.trim());
+}
+function supportsReasoningTokenBudget(model) {
+    const normalized = model.trim().toLowerCase();
+    return /^o\d/.test(normalized) || normalized.startsWith('gpt-5');
+}
+function sleep(ms, signal) {
+    return new Promise((resolve, reject) => {
+        const t = setTimeout(() => {
+            signal?.removeEventListener('abort', onAbort);
+            resolve();
+        }, ms);
+        const onAbort = () => {
+            clearTimeout(t);
+            reject(new DOMException('Aborted', 'AbortError'));
+        };
+        signal?.addEventListener('abort', onAbort, { once: true });
+    });
+}