icopilot 2.2.0

package/dist/agents/multi-repo.js

@@ -0,0 +1,350 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import fg from 'fast-glob';
+import simpleGit from 'simple-git';
+import { parseDocument, stringify } from 'yaml';
+const CONFIG_DIR = '.icopilot';
+const CONFIG_FILE = 'repos.yaml';
+const DEFAULT_GLOB = ['**/*'];
+const DEFAULT_IGNORES = [
+    '**/.git/**',
+    '**/.icopilot/**',
+    '**/node_modules/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/coverage/**',
+    '**/.next/**',
+    '**/.turbo/**',
+];
+const MAX_FILE_BYTES = 256 * 1024;
+const MAX_RESULTS = 50;
+const MAX_RESULTS_PER_REPO = 15;
+export class MultiRepoOrchestrator {
+    rootDir = process.cwd();
+    configPath = path.join(this.rootDir, CONFIG_DIR, CONFIG_FILE);
+    repos = [];
+    currentRepoName;
+    loadConfig(rootDir) {
+        this.rootDir = path.resolve(rootDir);
+        this.configPath = path.join(this.rootDir, CONFIG_DIR, CONFIG_FILE);
+        this.repos = [];
+        this.currentRepoName = undefined;
+        if (!fs.existsSync(this.configPath)) {
+            return this.listRepos();
+        }
+        const raw = fs.readFileSync(this.configPath, 'utf8');
+        const document = parseDocument(raw);
+        if (document.errors.length > 0) {
+            const [firstError] = document.errors;
+            throw new Error(`Invalid YAML in ${path.relative(process.cwd(), this.configPath)}: ${firstError?.message ?? 'parse error'}`);
+        }
+        const parsed = document.toJSON();
+        const normalized = normalizeConfigFile(parsed, this.rootDir, this.configPath);
+        this.currentRepoName = normalized.current;
+        this.repos = normalized.repos;
+        return this.listRepos();
+    }
+    addRepo(config) {
+        const normalized = normalizeRepoConfig(config, this.rootDir, this.configPath);
+        const existingByName = this.repos.find((repo) => repo.name.toLowerCase() === normalized.name.toLowerCase());
+        if (existingByName) {
+            throw new Error(`repository already exists: ${existingByName.name}`);
+        }
+        const existingByPath = this.repos.find((repo) => samePath(repo.path, normalized.path));
+        if (existingByPath) {
+            throw new Error(`repository path already exists: ${existingByPath.name}`);
+        }
+        this.repos.push(normalized);
+        if (!this.currentRepoName) {
+            this.currentRepoName = normalized.name;
+        }
+        this.saveConfig();
+        return cloneRepo(normalized);
+    }
+    removeRepo(name) {
+        const index = this.repos.findIndex((repo) => repo.name.toLowerCase() === name.toLowerCase());
+        if (index === -1)
+            return false;
+        const [removed] = this.repos.splice(index, 1);
+        if (removed && this.currentRepoName?.toLowerCase() === removed.name.toLowerCase()) {
+            this.currentRepoName = this.repos[0]?.name;
+        }
+        this.saveConfig();
+        return true;
+    }
+    listRepos() {
+        return this.repos.map(cloneRepo);
+    }
+    switchRepo(name) {
+        const repo = this.repos.find((entry) => entry.name.toLowerCase() === name.toLowerCase());
+        if (!repo) {
+            throw new Error(`unknown repository: ${name}`);
+        }
+        this.currentRepoName = repo.name;
+        this.saveConfig();
+        return cloneRepo(repo);
+    }
+    async searchAcrossRepos(query) {
+        const needle = query.trim().toLowerCase();
+        if (!needle)
+            return [];
+        const hits = [];
+        for (const repo of this.repos) {
+            if (hits.length >= MAX_RESULTS)
+                break;
+            if (!fs.existsSync(repo.path) || !fs.statSync(repo.path).isDirectory())
+                continue;
+            const files = await fg(DEFAULT_GLOB, {
+                cwd: repo.path,
+                onlyFiles: true,
+                dot: false,
+                ignore: DEFAULT_IGNORES,
+                absolute: true,
+                suppressErrors: true,
+            });
+            let repoHits = 0;
+            for (const absolutePath of files) {
+                if (hits.length >= MAX_RESULTS || repoHits >= MAX_RESULTS_PER_REPO)
+                    break;
+                const stat = safeStat(absolutePath);
+                if (!stat || stat.size > MAX_FILE_BYTES)
+                    continue;
+                const raw = fs.readFileSync(absolutePath, 'utf8');
+                if (raw.includes('\u0000'))
+                    continue;
+                const lines = raw.split(/\r?\n/);
+                for (let index = 0; index < lines.length; index += 1) {
+                    const line = lines[index] ?? '';
+                    if (!line.toLowerCase().includes(needle))
+                        continue;
+                    hits.push({
+                        repo: repo.name,
+                        file: path.relative(repo.path, absolutePath) || path.basename(absolutePath),
+                        line: index + 1,
+                        text: line.trim(),
+                        absolutePath,
+                    });
+                    repoHits += 1;
+                    if (hits.length >= MAX_RESULTS || repoHits >= MAX_RESULTS_PER_REPO)
+                        break;
+                }
+            }
+        }
+        return hits;
+    }
+    async getStatus() {
+        const repos = await Promise.all(this.repos.map(async (repo) => getRepoStatus(repo)));
+        return {
+            rootDir: this.rootDir,
+            configPath: this.configPath,
+            current: this.currentRepoName,
+            repos,
+        };
+    }
+    async syncAll() {
+        return Promise.all(this.repos.map(async (repo) => syncRepo(repo)));
+    }
+    getCurrentRepoName() {
+        return this.currentRepoName;
+    }
+    getConfigPath() {
+        return this.configPath;
+    }
+    getRootDir() {
+        return this.rootDir;
+    }
+    saveConfig() {
+        fs.mkdirSync(path.dirname(this.configPath), { recursive: true });
+        const document = {
+            current: this.currentRepoName,
+            repos: this.repos.map((repo) => ({
+                ...repo,
+                path: toPortableRelativePath(this.rootDir, repo.path),
+            })),
+        };
+        fs.writeFileSync(this.configPath, stringify(document), 'utf8');
+    }
+}
+async function getRepoStatus(repo) {
+    const base = {
+        ...cloneRepo(repo),
+        exists: false,
+        git: false,
+        dirty: false,
+        ahead: 0,
+        behind: 0,
+    };
+    if (!fs.existsSync(repo.path) || !fs.statSync(repo.path).isDirectory()) {
+        return { ...base, error: 'path does not exist' };
+    }
+    base.exists = true;
+    const git = simpleGit(repo.path);
+    try {
+        base.git = await git.checkIsRepo();
+        if (!base.git) {
+            return base;
+        }
+        const branch = await git.revparse(['--abbrev-ref', 'HEAD']);
+        const status = await git.status();
+        return {
+            ...base,
+            dirty: status.files.length > 0,
+            ahead: status.ahead,
+            behind: status.behind,
+            currentBranch: branch.trim(),
+        };
+    }
+    catch (error) {
+        return {
+            ...base,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+async function syncRepo(repo) {
+    const missing = !fs.existsSync(repo.path) || !fs.statSync(repo.path).isDirectory();
+    if (missing) {
+        return {
+            name: repo.name,
+            path: repo.path,
+            ok: false,
+            action: 'error',
+            message: 'path does not exist',
+        };
+    }
+    const git = simpleGit(repo.path);
+    try {
+        if (!(await git.checkIsRepo())) {
+            return {
+                name: repo.name,
+                path: repo.path,
+                ok: false,
+                action: 'skipped',
+                message: 'not a git repository',
+            };
+        }
+        const remotes = await git.getRemotes(true);
+        if (remotes.length === 0) {
+            return {
+                name: repo.name,
+                path: repo.path,
+                ok: true,
+                action: 'skipped',
+                message: 'no remotes configured',
+            };
+        }
+        await git.fetch(['--all', '--prune']);
+        const status = await git.status();
+        if (status.files.length > 0) {
+            return {
+                name: repo.name,
+                path: repo.path,
+                ok: true,
+                action: 'fetched',
+                message: 'fetched remotes; skipped pull because working tree is dirty',
+            };
+        }
+        const remoteName = repo.remote || remotes[0]?.name;
+        const branchName = repo.branch || (await git.revparse(['--abbrev-ref', 'HEAD'])).trim();
+        if (!remoteName || !branchName) {
+            return {
+                name: repo.name,
+                path: repo.path,
+                ok: true,
+                action: 'fetched',
+                message: 'fetched remotes',
+            };
+        }
+        await git.pull(remoteName, branchName, { '--ff-only': null });
+        return {
+            name: repo.name,
+            path: repo.path,
+            ok: true,
+            action: 'pulled',
+            message: `pulled ${remoteName}/${branchName}`,
+        };
+    }
+    catch (error) {
+        return {
+            name: repo.name,
+            path: repo.path,
+            ok: false,
+            action: 'error',
+            message: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function normalizeConfigFile(value, rootDir, configPath) {
+    if (Array.isArray(value)) {
+        return {
+            repos: value.map((repo) => normalizeRepoConfig(repo, rootDir, configPath)),
+        };
+    }
+    if (!value || typeof value !== 'object') {
+        throw new Error(`${path.relative(process.cwd(), configPath)} must contain a YAML object or array`);
+    }
+    const record = value;
+    const reposValue = record.repos;
+    if (reposValue !== undefined && !Array.isArray(reposValue)) {
+        throw new Error(`${path.relative(process.cwd(), configPath)} field "repos" must be an array`);
+    }
+    const currentValue = record.current;
+    if (currentValue !== undefined &&
+        (typeof currentValue !== 'string' || currentValue.trim().length === 0)) {
+        throw new Error(`${path.relative(process.cwd(), configPath)} field "current" must be a non-empty string`);
+    }
+    return {
+        ...(typeof currentValue === 'string' ? { current: currentValue.trim() } : {}),
+        repos: (reposValue ?? []).map((repo) => normalizeRepoConfig(repo, rootDir, configPath)),
+    };
+}
+function normalizeRepoConfig(value, rootDir, configPath) {
+    if (!value || typeof value !== 'object' || Array.isArray(value)) {
+        throw new Error(`${path.relative(process.cwd(), configPath)} repository entries must be YAML objects`);
+    }
+    const record = value;
+    const name = requiredString(record.name, 'name', configPath);
+    const repoPath = requiredString(record.path, 'path', configPath);
+    const role = requiredString(record.role, 'role', configPath);
+    return {
+        name,
+        path: path.resolve(rootDir, repoPath),
+        remote: optionalString(record.remote, 'remote', configPath),
+        branch: optionalString(record.branch, 'branch', configPath),
+        role,
+    };
+}
+function requiredString(value, field, configPath) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${path.relative(process.cwd(), configPath)} field "${field}" must be a non-empty string`);
+    }
+    return value.trim();
+}
+function optionalString(value, field, configPath) {
+    if (value === undefined || value === null || value === '')
+        return undefined;
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${path.relative(process.cwd(), configPath)} field "${field}" must be a non-empty string`);
+    }
+    return value.trim();
+}
+function cloneRepo(repo) {
+    return { ...repo };
+}
+function toPortableRelativePath(rootDir, targetPath) {
+    const relative = path.relative(rootDir, targetPath);
+    if (!relative)
+        return '.';
+    return relative.split(path.sep).join('/');
+}
+function samePath(left, right) {
+    return path.normalize(left) === path.normalize(right);
+}
+function safeStat(filePath) {
+    try {
+        return fs.statSync(filePath);
+    }
+    catch {
+        return null;
+    }
+}

package/dist/agents/parallel-runner.js

@@ -0,0 +1,181 @@
+import { activeProvider, client } from '../api/github-models.js';
+import { getAgentConfig } from '../commands/agent-cmd.js';
+import { aggregateResults } from './aggregator.js';
+const DEFAULT_CONCURRENCY_LIMIT = 5;
+const DEFAULT_TIMEOUT_MS = 60_000;
+const BUILT_IN_AGENT_TYPES = new Set(['explore', 'task', 'review', 'plan']);
+export class ParallelAgentRunner {
+    concurrencyLimit;
+    timeoutMs;
+    model;
+    onProgress;
+    executeTask;
+    constructor(options) {
+        this.model = options.model;
+        this.concurrencyLimit = normalizePositiveInt(options.concurrencyLimit, DEFAULT_CONCURRENCY_LIMIT);
+        this.timeoutMs = normalizePositiveInt(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+        this.onProgress = options.onProgress;
+        this.executeTask = options.executeTask ?? defaultExecuteTask;
+    }
+    async runParallel(agents) {
+        if (!agents.length) {
+            return {
+                results: [],
+                aggregated: aggregateResults([]),
+            };
+        }
+        const total = agents.length;
+        let completed = 0;
+        const limit = createConcurrencyLimiter(this.concurrencyLimit);
+        for (const agent of agents) {
+            this.onProgress?.({
+                name: agent.name,
+                type: agent.type,
+                status: 'queued',
+                completed,
+                total,
+            });
+        }
+        const executions = agents.map((agent) => limit(async () => {
+            this.onProgress?.({
+                name: agent.name,
+                type: agent.type,
+                status: 'started',
+                completed,
+                total,
+            });
+            const result = await this.runSingle(agent);
+            completed += 1;
+            this.onProgress?.({
+                name: agent.name,
+                type: agent.type,
+                status: result.status,
+                completed,
+                total,
+                result,
+            });
+            return result;
+        }));
+        const settled = await Promise.allSettled(executions);
+        const results = settled.map((entry, index) => {
+            if (entry.status === 'fulfilled')
+                return entry.value;
+            return {
+                name: agents[index]?.name ?? `agent-${index + 1}`,
+                status: 'error',
+                output: formatError(entry.reason),
+                duration: 0,
+            };
+        });
+        return {
+            results,
+            aggregated: aggregateResults(results
+                .filter((result) => result.status === 'success')
+                .map((result) => ({
+                name: result.name,
+                output: result.output,
+            }))),
+        };
+    }
+    async runSingle(task) {
+        const startedAt = Date.now();
+        try {
+            const output = await this.executeWithTimeout(task);
+            return {
+                name: task.name,
+                status: 'success',
+                output,
+                duration: Date.now() - startedAt,
+            };
+        }
+        catch (error) {
+            return {
+                name: task.name,
+                status: 'error',
+                output: formatError(error),
+                duration: Date.now() - startedAt,
+            };
+        }
+    }
+    async executeWithTimeout(task) {
+        const controller = new AbortController();
+        let timedOut = false;
+        const timeout = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, this.timeoutMs);
+        try {
+            return await this.executeTask(task, {
+                model: this.model,
+                signal: controller.signal,
+                systemPrompt: resolveSystemPrompt(task),
+            });
+        }
+        catch (error) {
+            if (timedOut) {
+                throw new Error(`Timed out after ${this.timeoutMs}ms`);
+            }
+            throw error;
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+}
+async function defaultExecuteTask(task, options) {
+    const provider = activeProvider();
+    const messages = [
+        { role: 'system', content: options.systemPrompt },
+        { role: 'user', content: task.prompt },
+    ];
+    const response = await client().chat.completions.create({
+        model: options.model,
+        messages,
+        temperature: 0.2,
+        ...(provider?.maxTokens ? { max_tokens: provider.maxTokens } : {}),
+    }, { signal: options.signal });
+    return response.choices[0]?.message?.content?.trim() || '';
+}
+function resolveSystemPrompt(task) {
+    const inlinePrompt = task.systemPrompt?.trim();
+    if (inlinePrompt)
+        return inlinePrompt;
+    if (BUILT_IN_AGENT_TYPES.has(task.type)) {
+        return getAgentConfig(task.type).systemPrompt;
+    }
+    return 'You are a specialized sub-agent. Complete the assigned task accurately and concisely.';
+}
+function createConcurrencyLimiter(limit) {
+    let activeCount = 0;
+    const queue = [];
+    const next = () => {
+        activeCount -= 1;
+        const resume = queue.shift();
+        resume?.();
+    };
+    return async function runLimited(fn) {
+        if (activeCount >= limit) {
+            await new Promise((resolve) => queue.push(resolve));
+        }
+        activeCount += 1;
+        try {
+            return await fn();
+        }
+        finally {
+            next();
+        }
+    };
+}
+function normalizePositiveInt(value, fallback) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 1) {
+        return fallback;
+    }
+    return Math.floor(value);
+}
+function formatError(error) {
+    if (error instanceof Error)
+        return error.message;
+    if (typeof error === 'string')
+        return error;
+    return 'Unknown error';
+}

package/dist/agents/router.js

@@ -0,0 +1,144 @@
+const DEFAULT_THRESHOLD = 0.7;
+const KEYWORD_BOOST = 0.12;
+const QUESTION_BOOST = 0.16;
+const STARTS_WITH_BOOST = 0.08;
+const DEFAULT_ROUTES = [
+    {
+        pattern: ['review', 'code review', 'audit', 'inspect'],
+        agentType: 'review',
+        confidence: 0.5,
+    },
+    {
+        pattern: ['explain', 'how', 'why', 'what does'],
+        agentType: 'explain',
+        confidence: 0.48,
+    },
+    {
+        pattern: ['fix', 'error', 'bug', 'broken', 'failing', 'debug'],
+        agentType: 'fix',
+        confidence: 0.52,
+    },
+    {
+        pattern: ['refactor', 'improve', 'cleanup', 'clean up', 'optimize', 'simplify'],
+        agentType: 'refactor',
+        confidence: 0.5,
+    },
+    {
+        pattern: ['test', 'tests', 'spec', 'specs'],
+        agentType: 'test',
+        confidence: 0.5,
+    },
+    {
+        pattern: ['explore', 'find', 'where', 'locate', 'search'],
+        agentType: 'explore',
+        confidence: 0.48,
+    },
+    {
+        pattern: ['plan', 'design', 'architect', 'architecture', 'approach'],
+        agentType: 'plan',
+        confidence: 0.5,
+    },
+];
+const QUESTION_PATTERNS = {
+    review: [/\breview\b/, /\baudit\b/, /\binspect\b/],
+    explain: [/^(?:can you\s+)?(?:explain|how|why)\b/, /\bwhat does\b/, /\bhow does\b/],
+    fix: [/^(?:please\s+)?(?:fix|debug)\b/, /\b(?:error|bug|broken|failing)\b/],
+    refactor: [/^(?:please\s+)?(?:refactor|improve)\b/, /\bclean up\b/, /\boptimi[sz]e\b/],
+    test: [/^(?:add|write|create)?\s*tests?\b/, /\bspecs?\b/, /\btest\b/],
+    explore: [/^(?:where|find|locate|explore)\b/, /\bwhere is\b/, /\bfind\b/],
+    plan: [/^(?:plan|design|architect)\b/, /\barchitecture\b/, /\bhow should we\b/],
+};
+const STARTS_WITH_PATTERNS = {
+    review: [/^(?:please\s+)?review\b/],
+    explain: [/^(?:can you\s+)?(?:explain|how|why)\b/],
+    fix: [/^(?:please\s+)?(?:fix|debug)\b/],
+    refactor: [/^(?:please\s+)?(?:refactor|improve)\b/],
+    test: [/^(?:please\s+)?(?:test|spec|add tests?|write tests?)\b/],
+    explore: [/^(?:please\s+)?(?:explore|find|where|locate)\b/],
+    plan: [/^(?:please\s+)?(?:plan|design|architect)\b/],
+};
+const customRoutes = [];
+let threshold = readThreshold(process.env.ICOPILOT_AGENT_ROUTE_THRESHOLD);
+export function routeQuery(query) {
+    const normalizedQuery = normalizeQuery(query);
+    if (!normalizedQuery) {
+        return null;
+    }
+    let bestMatch = null;
+    for (const route of [...customRoutes, ...DEFAULT_ROUTES]) {
+        const score = scoreRoute(route, normalizedQuery);
+        if (!score) {
+            continue;
+        }
+        if (!bestMatch || score > bestMatch.confidence) {
+            bestMatch = { agent: route.agentType, confidence: score };
+        }
+    }
+    if (!bestMatch || bestMatch.confidence < threshold) {
+        return null;
+    }
+    return bestMatch;
+}
+export function addRoute(route) {
+    customRoutes.unshift({
+        ...route,
+        confidence: clampConfidence(route.confidence),
+    });
+}
+export function setRouteThreshold(nextThreshold) {
+    threshold = clampConfidence(nextThreshold);
+}
+export function getRouteThreshold() {
+    return threshold;
+}
+function scoreRoute(route, normalizedQuery) {
+    const keywordMatches = countMatches(route.pattern, normalizedQuery);
+    if (keywordMatches === 0) {
+        return 0;
+    }
+    let score = clampConfidence(route.confidence);
+    score += Math.min(0.24, keywordMatches * KEYWORD_BOOST);
+    score += Math.min(0.24, countSignalMatches(route.agentType, normalizedQuery, QUESTION_PATTERNS) * QUESTION_BOOST);
+    if (hasStartsWithSignal(route.agentType, normalizedQuery)) {
+        score += STARTS_WITH_BOOST;
+    }
+    return roundConfidence(score);
+}
+function countMatches(pattern, normalizedQuery) {
+    if (pattern instanceof RegExp) {
+        const flags = pattern.flags.includes('g') ? pattern.flags : `${pattern.flags}g`;
+        const matcher = new RegExp(pattern.source, flags);
+        return [...normalizedQuery.matchAll(matcher)].length;
+    }
+    return pattern.reduce((count, keyword) => count + (hasKeywordMatch(keyword, normalizedQuery) ? 1 : 0), 0);
+}
+function countSignalMatches(agentType, normalizedQuery, patternsByAgent) {
+    return (patternsByAgent[agentType] ?? []).reduce((count, pattern) => count + (pattern.test(normalizedQuery) ? 1 : 0), 0);
+}
+function hasStartsWithSignal(agentType, normalizedQuery) {
+    return (STARTS_WITH_PATTERNS[agentType] ?? []).some((pattern) => pattern.test(normalizedQuery));
+}
+function hasKeywordMatch(keyword, normalizedQuery) {
+    const escapedKeyword = escapeRegExp(keyword.toLowerCase());
+    const keywordPattern = new RegExp(`(?:^|\\b)${escapedKeyword}(?=\\b|$)`);
+    return keywordPattern.test(normalizedQuery);
+}
+function normalizeQuery(query) {
+    return query.trim().toLowerCase().replace(/\s+/g, ' ');
+}
+function readThreshold(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? clampConfidence(parsed) : DEFAULT_THRESHOLD;
+}
+function clampConfidence(value) {
+    if (!Number.isFinite(value)) {
+        return DEFAULT_THRESHOLD;
+    }
+    return Math.min(1, Math.max(0, value));
+}
+function roundConfidence(value) {
+    return Math.round(clampConfidence(value) * 100) / 100;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}