scalix 0.0.1 → 1.0.0

package/dist/hooks.js

@@ -0,0 +1,94 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+import { logger } from './logger.js';
+import { PROJECT_LOOKUP_DIRS, HOOK_DEFAULTS } from './constants.js';
+const execAsync = promisify(exec);
+const HOOK_PATHS = PROJECT_LOOKUP_DIRS.map(d => `${d}/hooks.json`);
+export function loadHooks(cwd = process.cwd()) {
+    for (const relPath of HOOK_PATHS) {
+        const fullPath = resolve(cwd, relPath);
+        if (!existsSync(fullPath))
+            continue;
+        try {
+            const raw = readFileSync(fullPath, 'utf-8');
+            const parsed = JSON.parse(raw);
+            if (parsed?.hooks && Array.isArray(parsed.hooks)) {
+                return parsed.hooks.filter((h) => typeof h.event === 'string' && typeof h.command === 'string');
+            }
+        }
+        catch (err) {
+            logger.warn('Failed to load hooks config', { path: fullPath, error: err.message });
+        }
+    }
+    return [];
+}
+function matchesHook(hook, toolName) {
+    if (!hook.match)
+        return true;
+    if (!toolName)
+        return false;
+    if (hook.match === toolName)
+        return true;
+    if (hook.match.endsWith('*')) {
+        return toolName.startsWith(hook.match.slice(0, -1));
+    }
+    return false;
+}
+export async function executeHook(hook, env) {
+    const timeout = hook.timeout ?? HOOK_DEFAULTS.timeoutMs;
+    const hookEnv = { ...process.env, ...env };
+    try {
+        const { stdout, stderr } = await execAsync(hook.command, {
+            timeout,
+            env: hookEnv,
+            maxBuffer: HOOK_DEFAULTS.maxBuffer,
+        });
+        return { allowed: true, output: (stdout || stderr).trim() || undefined };
+    }
+    catch (err) {
+        if (err.killed || err.code === 'ETIMEDOUT') {
+            return { allowed: false, error: `Hook timed out after ${timeout}ms` };
+        }
+        return {
+            allowed: err.code === 0,
+            output: (err.stdout || '').trim() || undefined,
+            error: (err.stderr || err.message || '').trim(),
+        };
+    }
+}
+export async function runHooks(hooks, event, context) {
+    const matching = hooks.filter((h) => h.event === event && matchesHook(h, context.toolName));
+    if (matching.length === 0)
+        return [];
+    const env = {};
+    if (context.toolName)
+        env.SCALIX_TOOL_NAME = context.toolName;
+    if (context.toolArgs)
+        env.SCALIX_TOOL_ARGS = context.toolArgs;
+    if (context.error)
+        env.SCALIX_ERROR = context.error;
+    if (context.prompt)
+        env.SCALIX_PROMPT = context.prompt.slice(0, 4096).replace(/[\x00-\x08\x0b\x0c\x0e-\x1f]/g, '');
+    env.SCALIX_EVENT = event;
+    const results = [];
+    for (const hook of matching) {
+        const result = await executeHook(hook, env);
+        results.push(result);
+        logger.debug('Hook executed', { event, command: hook.command, allowed: result.allowed });
+        if (!result.allowed && event === 'PreToolUse')
+            break;
+    }
+    return results;
+}
+export function hooksSummary(hooks) {
+    if (hooks.length === 0)
+        return 'No hooks configured.';
+    const lines = ['Configured hooks:'];
+    for (const h of hooks) {
+        const match = h.match ? ` (match: ${h.match})` : '';
+        lines.push(`  ${h.event}${match}: ${h.command}`);
+    }
+    return lines.join('\n');
+}

package/dist/ipc-server.js

@@ -0,0 +1,228 @@
+/**
+ * IPC server mode — JSONL protocol over stdin/stdout for the VS Code extension.
+ * Spawned by the extension to use the full CLI agent with all tools and features.
+ *
+ * Protocol:
+ *   stdin  (client→server): {"type":"request","id":"...","method":"...","params":{}}
+ *                           {"type":"response","id":"...","result":{}}   (for confirmTool)
+ *   stdout (server→client): {"type":"event","event":"...","data":{}}
+ *                           {"type":"response","id":"...","result":{}}
+ *                           {"type":"request","id":"...","method":"confirmTool","params":{}}
+ */
+import readline from 'node:readline';
+import { createAgent } from './agent.js';
+import { defaultTools } from './tools.js';
+import { extraTools } from './tools-extra.js';
+import { webTools } from './tools-web.js';
+import { advancedTools } from './tools-advanced.js';
+import { visionTools } from './tools-vision.js';
+import { voiceTools } from './tools-voice.js';
+import { browserTools } from './tools-browser.js';
+import { loadMcpServices } from './mcp.js';
+import { loadConfig, DEFAULT_LIMITS } from './settings.js';
+import { discoverPlugins, getPluginTools } from './plugins.js';
+import { DEFAULT_MODELS, DEFAULT_INSTRUCTIONS, ENV_API_KEY, ENV_MODEL, ENV_BASE_URL, fetchModelSpecs } from './constants.js';
+import { loadMemory, autoDetectConventions, saveMemory } from './project-memory.js';
+import { buildProjectContext, contextToInstructions } from './context-builder.js';
+const pendingConfirms = new Map();
+let confirmCounter = 0;
+function write(msg) {
+    process.stdout.write(JSON.stringify(msg) + '\n');
+}
+async function buildInstructions() {
+    let base = DEFAULT_INSTRUCTIONS;
+    const cwd = process.cwd();
+    try {
+        const mem = await loadMemory(cwd);
+        const auto = await autoDetectConventions(cwd);
+        for (const c of auto) {
+            if (!mem.conventions.some(mc => mc.key === c.key))
+                mem.conventions.push(c);
+        }
+        if (mem.conventions.length > 0 || mem.patterns.length > 0 || mem.notes.length > 0) {
+            await saveMemory(cwd, mem);
+        }
+    }
+    catch { }
+    const ctx = await buildProjectContext(cwd);
+    return contextToInstructions(base, ctx);
+}
+export async function runIpcServer() {
+    // Keep stdout clean for JSONL — redirect console to stderr
+    console.log = (...a) => { process.stderr.write(a.map(String).join(' ') + '\n'); };
+    console.error = (...a) => { process.stderr.write(a.map(String).join(' ') + '\n'); };
+    console.warn = (...a) => { process.stderr.write(a.map(String).join(' ') + '\n'); };
+    const config = await loadConfig();
+    const apiKey = process.env[ENV_API_KEY] || config.apiKey || '';
+    if (!apiKey) {
+        write({ type: 'event', event: 'error', data: { message: 'SCALIX_API_KEY not set' } });
+        process.exit(1);
+    }
+    const limits = config.limits || DEFAULT_LIMITS;
+    const envModels = process.env[ENV_MODEL]
+        ? process.env[ENV_MODEL].split(',').map(m => m.trim()).filter(Boolean)
+        : [];
+    const selectedModels = envModels.length > 0
+        ? envModels
+        : config.models.length > 0 ? config.models : DEFAULT_MODELS;
+    const baseUrl = process.env[ENV_BASE_URL] || config.baseUrl;
+    fetchModelSpecs(baseUrl, apiKey).catch(() => { });
+    const mcpTools = loadMcpServices();
+    const plugins = await discoverPlugins(process.cwd());
+    const pluginTools = getPluginTools(plugins);
+    const allTools = [...defaultTools, ...extraTools, ...webTools, ...advancedTools, ...visionTools, ...voiceTools, ...browserTools, ...mcpTools, ...pluginTools];
+    const instructions = await buildInstructions();
+    // Bidirectional confirm: send request to VS Code, wait for response
+    const confirmToolCall = async (toolName, args) => {
+        const id = `confirm_${++confirmCounter}`;
+        write({ type: 'request', id, method: 'confirmTool', params: { name: toolName, args } });
+        return new Promise(resolve => {
+            let resolved = false;
+            const safeResolve = (v) => { if (!resolved) {
+                resolved = true;
+                resolve(v);
+            } };
+            pendingConfirms.set(id, { resolve: safeResolve });
+            const timer = setTimeout(() => {
+                if (pendingConfirms.has(id)) {
+                    pendingConfirms.delete(id);
+                    safeResolve(false);
+                }
+            }, 60_000);
+            pendingConfirms.set(id, { resolve: (v) => { clearTimeout(timer); safeResolve(v); } });
+        });
+    };
+    const permissionMode = (process.env.SCALIX_PERMISSION_MODE || config.permissionMode || 'default');
+    const agent = createAgent({
+        apiKey,
+        baseUrl,
+        model: selectedModels,
+        instructions,
+        tools: allTools,
+        permissionMode,
+        maxSteps: limits.maxSteps,
+        maxMessages: limits.maxMessages,
+        contextManager: {
+            maxContextTokens: limits.maxContextTokens,
+            compressionThreshold: limits.compressionThreshold,
+            maxToolResultTokens: limits.maxToolResultTokens,
+        },
+        instructionLoader: buildInstructions,
+        confirmToolCall,
+        autoVerify: true,
+    });
+    // Forward all agent events as JSONL
+    agent.on('stream:delta', (d, a) => write({ type: 'event', event: 'stream:delta', data: { delta: d, accumulated: a } }));
+    agent.on('stream:end', t => write({ type: 'event', event: 'stream:end', data: { text: t } }));
+    agent.on('tool:call', (n, a) => write({ type: 'event', event: 'tool:call', data: { name: n, args: a } }));
+    agent.on('tool:result', (n, r) => write({ type: 'event', event: 'tool:result', data: { name: n, result: r } }));
+    agent.on('tool:blocked', (n, r) => write({ type: 'event', event: 'tool:blocked', data: { name: n, reason: r } }));
+    agent.on('thinking:start', () => write({ type: 'event', event: 'thinking:start' }));
+    agent.on('thinking:end', () => write({ type: 'event', event: 'thinking:end' }));
+    agent.on('usage', d => write({ type: 'event', event: 'usage', data: d }));
+    agent.on('error', e => write({ type: 'event', event: 'error', data: { message: e.message } }));
+    agent.on('context:compress', i => write({ type: 'event', event: 'context:compress', data: i }));
+    agent.on('context:usage', i => write({ type: 'event', event: 'context:usage', data: i }));
+    // Signal ready with capability info
+    write({ type: 'event', event: 'ready', data: { tools: allTools.length, models: selectedModels, permissionMode } });
+    // Process JSONL from stdin
+    let busy = false;
+    const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+    rl.on('line', async (line) => {
+        let msg;
+        try {
+            msg = JSON.parse(line);
+        }
+        catch {
+            process.stderr.write(`IPC: invalid JSON: ${line.slice(0, 100)}\n`);
+            return;
+        }
+        // Response to server-initiated confirmTool request
+        if (msg.type === 'response' && pendingConfirms.has(msg.id)) {
+            const { resolve } = pendingConfirms.get(msg.id);
+            pendingConfirms.delete(msg.id);
+            resolve(msg.result?.allowed ?? false);
+            return;
+        }
+        if (msg.type !== 'request')
+            return;
+        const { id, method, params } = msg;
+        try {
+            switch (method) {
+                case 'send': {
+                    if (!params?.content) {
+                        write({ type: 'response', id, error: { message: 'Missing content' } });
+                        break;
+                    }
+                    if (busy) {
+                        write({ type: 'response', id, error: { message: 'Agent is busy' } });
+                        break;
+                    }
+                    busy = true;
+                    write({ type: 'event', event: 'status', data: { status: 'thinking' } });
+                    try {
+                        const images = params.images;
+                        const text = await agent.send(params.content, images);
+                        write({ type: 'response', id, result: { text } });
+                    }
+                    catch (err) {
+                        write({ type: 'response', id, error: { message: err.message } });
+                    }
+                    finally {
+                        busy = false;
+                        write({ type: 'event', event: 'status', data: { status: 'idle' } });
+                    }
+                    break;
+                }
+                case 'abort':
+                    agent.abort();
+                    write({ type: 'response', id, result: { success: true } });
+                    break;
+                case 'clear':
+                    agent.clearHistory();
+                    write({ type: 'response', id, result: { success: true } });
+                    break;
+                case 'setModel':
+                    if (params?.model)
+                        agent.setModel(params.model);
+                    write({ type: 'response', id, result: { model: agent.getModels()[0] } });
+                    break;
+                case 'compact': {
+                    const r = await agent.compact();
+                    write({ type: 'response', id, result: { message: r } });
+                    break;
+                }
+                case 'getModels':
+                    write({ type: 'response', id, result: { models: agent.getModels() } });
+                    break;
+                case 'getContextInfo': {
+                    const u = agent.getContextUsage();
+                    write({ type: 'response', id, result: {
+                            estimatedTokens: u.tokens, maxTokens: u.maxTokens,
+                            messageCount: agent.getMessages().length, utilization: u.percentage / 100,
+                        } });
+                    break;
+                }
+                case 'getMessages':
+                    write({ type: 'response', id, result: { messages: agent.getMessages() } });
+                    break;
+                case 'loadMessages':
+                    if (params?.messages)
+                        agent.loadMessages(params.messages);
+                    write({ type: 'response', id, result: { success: true } });
+                    break;
+                case 'setPermissionMode':
+                    if (params?.mode)
+                        agent.setPermissionMode(params.mode);
+                    write({ type: 'response', id, result: { mode: agent.getPermissionMode() } });
+                    break;
+                default:
+                    write({ type: 'response', id, error: { message: `Unknown method: ${method}` } });
+            }
+        }
+        catch (err) {
+            write({ type: 'response', id, error: { message: err.message } });
+        }
+    });
+    rl.on('close', () => process.exit(0));
+}

package/dist/logger.js

@@ -0,0 +1,45 @@
+import { randomUUID } from 'node:crypto';
+const LEVELS = { debug: 0, info: 1, warn: 2, error: 3, silent: 4 };
+export class Logger {
+    level;
+    requestId;
+    constructor(level = 'info') {
+        this.level = level;
+    }
+    child(requestId) {
+        const child = new Logger(this.level);
+        child.requestId = requestId ?? randomUUID().slice(0, 8);
+        return child;
+    }
+    shouldLog(level) {
+        return LEVELS[level] >= LEVELS[this.level];
+    }
+    format(entry) {
+        const parts = [entry.timestamp, `[${entry.level.toUpperCase()}]`];
+        if (entry.requestId)
+            parts.push(`[${entry.requestId}]`);
+        parts.push(entry.message);
+        if (entry.data)
+            parts.push(JSON.stringify(entry.data));
+        return parts.join(' ');
+    }
+    log(level, message, data) {
+        if (!this.shouldLog(level))
+            return;
+        const entry = {
+            timestamp: new Date().toISOString(),
+            level,
+            requestId: this.requestId,
+            message,
+            data,
+        };
+        const output = this.format(entry);
+        process.stderr.write(output + '\n');
+    }
+    setLevel(level) { this.level = level; }
+    debug(msg, data) { this.log('debug', msg, data); }
+    info(msg, data) { this.log('info', msg, data); }
+    warn(msg, data) { this.log('warn', msg, data); }
+    error(msg, data) { this.log('error', msg, data); }
+}
+export const logger = new Logger(process.env.LOG_LEVEL || 'info');

package/dist/markdown.js

@@ -0,0 +1,41 @@
+import chalk from 'chalk';
+import { Marked } from 'marked';
+import { markedTerminal } from 'marked-terminal';
+function createMarked(width) {
+    const m = new Marked();
+    const mt = markedTerminal({
+        strong: chalk.bold,
+        em: chalk.italic,
+        codespan: chalk.cyan,
+        code: chalk.yellow,
+        heading: chalk.green.bold,
+        firstHeading: chalk.magenta.bold,
+        hr: chalk.dim,
+        link: chalk.blue,
+        href: chalk.blue.underline,
+        blockquote: chalk.gray.italic,
+        del: chalk.dim.strikethrough,
+        width,
+        showSectionPrefix: true,
+        reflowText: false,
+        tab: 2,
+    });
+    m.use(mt);
+    return m;
+}
+let cachedWidth = 0;
+let cachedMarked = null;
+export function renderMarkdown(text, cols) {
+    const width = Math.max((cols ?? process.stdout.columns ?? 100) - 6, 40);
+    if (!cachedMarked || width !== cachedWidth) {
+        cachedWidth = width;
+        cachedMarked = createMarked(width);
+    }
+    try {
+        const result = cachedMarked.parse(text);
+        return result.replace(/\n{3,}/g, '\n\n').trim();
+    }
+    catch {
+        return text;
+    }
+}

package/dist/mcp.js

@@ -0,0 +1,49 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { McpServicesConfigSchema } from './config.js';
+import { logger } from './logger.js';
+function resolveAuthorization(config) {
+    if (config.authorization)
+        return config.authorization;
+    if (config.authorizationEnv) {
+        const value = process.env[config.authorizationEnv];
+        if (typeof value === 'string' && value.trim().length > 0)
+            return value;
+    }
+    return undefined;
+}
+function toMcpTool(config) {
+    return {
+        type: 'mcp',
+        serverLabel: config.serverLabel,
+        serverUrl: config.serverUrl,
+        serverDescription: config.serverDescription,
+        authorization: resolveAuthorization(config),
+        headers: config.headers,
+        allowedTools: config.allowedTools,
+    };
+}
+export function loadMcpServices(configPath = 'mcp-services.json') {
+    const absolutePath = resolve(process.cwd(), configPath);
+    if (!existsSync(absolutePath))
+        return [];
+    try {
+        const raw = readFileSync(absolutePath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const validated = McpServicesConfigSchema.parse(parsed);
+        return validated.mcpServers
+            .filter((s) => {
+            const url = s.serverUrl.toLowerCase();
+            if (url.includes('example.com') || url.includes('your-') || url.includes('placeholder')) {
+                logger.warn(`Skipping MCP "${s.serverLabel}": placeholder URL detected`, { url: s.serverUrl });
+                return false;
+            }
+            return true;
+        })
+            .map(toMcpTool);
+    }
+    catch (err) {
+        logger.error('Failed to load MCP config', { path: absolutePath, error: err.message });
+        return [];
+    }
+}

package/dist/model-router.js

@@ -0,0 +1,68 @@
+import { COMPLEXITY_PATTERNS, ROUTING_DEFAULTS } from './constants.js';
+export function classifyComplexity(query, toolCallCount = 0, config) {
+    if (toolCallCount > ROUTING_DEFAULTS.toolCallComplexThreshold)
+        return 'complex';
+    const simplePatterns = config?.simplePatterns ?? COMPLEXITY_PATTERNS.simple;
+    const complexPatterns = config?.complexPatterns ?? COMPLEXITY_PATTERNS.complex;
+    for (const p of simplePatterns) {
+        if (p.test(query))
+            return 'simple';
+    }
+    for (const p of complexPatterns) {
+        if (p.test(query))
+            return 'complex';
+    }
+    const wordCount = query.split(/\s+/).length;
+    if (wordCount <= ROUTING_DEFAULTS.simpleWordMax)
+        return 'simple';
+    if (wordCount >= ROUTING_DEFAULTS.complexWordMin)
+        return 'complex';
+    return 'moderate';
+}
+export function selectModel(query, config, toolCallCount = 0) {
+    if (!config.enabled || config.tiers.length === 0) {
+        return config.defaultModel;
+    }
+    const complexity = classifyComplexity(query, toolCallCount, {
+        simplePatterns: config.simplePatterns,
+        complexPatterns: config.complexPatterns,
+    });
+    const tier = config.tiers.find((t) => t.complexity.includes(complexity));
+    if (tier)
+        return tier.model;
+    const fallback = config.tiers.find((t) => t.complexity.includes('moderate'));
+    return fallback?.model || config.defaultModel;
+}
+export function createRouterConfig(models, enabled = false) {
+    if (models.length === 0) {
+        return { tiers: [], enabled: false, defaultModel: '' };
+    }
+    if (models.length === 1) {
+        return {
+            tiers: [{ model: models[0], complexity: ['simple', 'moderate', 'complex'] }],
+            enabled,
+            defaultModel: models[0],
+        };
+    }
+    const tiers = [];
+    if (models.length >= 3) {
+        tiers.push({ model: models[0], complexity: ['simple'] });
+        tiers.push({ model: models[1], complexity: ['moderate'] });
+        tiers.push({ model: models[2], complexity: ['complex'] });
+    }
+    else {
+        tiers.push({ model: models[0], complexity: ['simple', 'moderate'] });
+        tiers.push({ model: models[1], complexity: ['complex'] });
+    }
+    return { tiers, enabled, defaultModel: models[0] };
+}
+export function getRouterStatus(config) {
+    if (!config.enabled)
+        return 'Model routing: disabled (using single model)';
+    const lines = ['Model routing: enabled'];
+    for (const tier of config.tiers) {
+        const model = tier.model.split('/').pop()?.replace(/:free$/, '') || tier.model;
+        lines.push(`  ${tier.complexity.join(', ')} → ${model}`);
+    }
+    return lines.join('\n');
+}

package/dist/plugins.js

@@ -0,0 +1,132 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { z } from 'zod';
+import { PROJECT_CONFIG_DIR, PLUGIN_DEFAULTS } from './constants.js';
+const PLUGINS_DIR = `${PROJECT_CONFIG_DIR}/plugins`;
+const manifestSchema = z.object({
+    name: z.string(),
+    version: z.string().default('1.0.0'),
+    description: z.string().default(''),
+    tools: z.array(z.object({
+        name: z.string(),
+        description: z.string(),
+        inputSchema: z.record(z.string(), z.unknown()).default({}),
+        handler: z.string(),
+    })),
+    permissions: z.object({
+        allowedTools: z.array(z.string()).optional(),
+        blockedTools: z.array(z.string()).optional(),
+        permissionMode: z.enum(['plan', 'default', 'auto']).optional(),
+    }).optional(),
+});
+let _pluginCache = new Map();
+const CACHE_TTL_MS = PLUGIN_DEFAULTS.cacheTtlMs;
+async function loadPluginHandler(pluginDir, handlerPath) {
+    const fullPath = path.resolve(pluginDir, handlerPath);
+    const normalizedFull = path.normalize(fullPath);
+    const normalizedDir = path.normalize(pluginDir) + path.sep;
+    if (!normalizedFull.startsWith(normalizedDir)) {
+        throw new Error(`Plugin handler path escapes plugin directory: ${handlerPath}`);
+    }
+    try {
+        await fs.access(fullPath);
+    }
+    catch {
+        throw new Error(`Plugin handler not found: ${fullPath}`);
+    }
+    const fileUrl = pathToFileURL(fullPath).href;
+    const mod = await import(fileUrl);
+    if (typeof mod.default === 'function')
+        return mod.default;
+    if (typeof mod.execute === 'function')
+        return mod.execute;
+    if (typeof mod.handler === 'function')
+        return mod.handler;
+    throw new Error(`Plugin handler ${handlerPath} must export default, execute, or handler function`);
+}
+export async function loadPlugin(pluginDir) {
+    const manifestPath = path.join(pluginDir, 'plugin.json');
+    try {
+        await fs.access(manifestPath);
+    }
+    catch {
+        return null;
+    }
+    try {
+        const raw = await fs.readFile(manifestPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        const manifest = manifestSchema.parse(parsed);
+        const tools = [];
+        for (const toolDef of manifest.tools) {
+            try {
+                const handler = await loadPluginHandler(pluginDir, toolDef.handler);
+                tools.push({
+                    type: 'function',
+                    function: {
+                        name: `plugin_${manifest.name}_${toolDef.name}`,
+                        description: `[Plugin: ${manifest.name}] ${toolDef.description}`,
+                        parameters: toolDef.inputSchema,
+                        execute: handler,
+                    },
+                });
+            }
+            catch (err) {
+                process.stderr.write(`Warning: failed to load plugin tool ${toolDef.name}: ${err.message}\n`);
+            }
+        }
+        return { manifest, tools, path: pluginDir };
+    }
+    catch (err) {
+        process.stderr.write(`Warning: failed to load plugin from ${pluginDir}: ${err.message}\n`);
+        return null;
+    }
+}
+export async function discoverPlugins(projectRoot) {
+    const cached = _pluginCache.get(projectRoot);
+    if (cached && Date.now() - cached.timestamp < CACHE_TTL_MS) {
+        return cached.plugins;
+    }
+    const pluginsDir = path.join(projectRoot, PLUGINS_DIR);
+    const plugins = [];
+    try {
+        await fs.access(pluginsDir);
+    }
+    catch {
+        return [];
+    }
+    try {
+        const entries = await fs.readdir(pluginsDir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const pluginDir = path.join(pluginsDir, entry.name);
+            const plugin = await loadPlugin(pluginDir);
+            if (plugin)
+                plugins.push(plugin);
+        }
+        const rootPlugin = await loadPlugin(pluginsDir);
+        if (rootPlugin)
+            plugins.push(rootPlugin);
+    }
+    catch {
+        return [];
+    }
+    _pluginCache.set(projectRoot, { plugins, timestamp: Date.now() });
+    return plugins;
+}
+export function getPluginTools(plugins) {
+    return plugins.flatMap((p) => p.tools);
+}
+export function pluginsSummary(plugins) {
+    if (plugins.length === 0)
+        return 'No plugins loaded.';
+    const lines = [`${plugins.length} plugin(s) loaded:`];
+    for (const p of plugins) {
+        lines.push(`  ${p.manifest.name} v${p.manifest.version} (${p.tools.length} tools)`);
+        for (const t of p.tools) {
+            lines.push(`    - ${t.function.name}: ${t.function.description}`);
+        }
+    }
+    return lines.join('\n');
+}