brainclaw 0.19.2

package/dist/core/agent-integrations.js

@@ -0,0 +1,135 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+const SUPPORTED_AGENT_INTEGRATION_NAMES = new Set([
+    'github-copilot',
+    'claude-code',
+    'cursor',
+    'windsurf',
+    'cline',
+    'codex',
+    'opencode',
+    'antigravity',
+    'continue',
+    'roo',
+]);
+const DEFAULT_SURFACES = {
+    'github-copilot': [
+        { kind: 'instructions', location: 'workspace', path: '.github/copilot-instructions.md' },
+        { kind: 'skill', location: 'workspace', path: '.github/skills/brainclaw-context/SKILL.md' },
+    ],
+    'claude-code': [
+        { kind: 'instructions', location: 'workspace', path: 'CLAUDE.md' },
+        { kind: 'mcp', location: 'workspace', path: '.mcp.json' },
+        { kind: 'skill', location: 'workspace', path: '.claude/commands/brainclaw.md' },
+    ],
+    'cursor': [
+        { kind: 'instructions', location: 'workspace', path: '.cursor/rules/brainclaw.md' },
+        { kind: 'rule', location: 'workspace', path: '.cursor/rules/brainclaw-mcp-shim.mdc' },
+        { kind: 'mcp', location: 'machine', path: '.cursor/mcp.json' },
+    ],
+    'windsurf': [
+        { kind: 'instructions', location: 'workspace', path: '.windsurfrules' },
+        { kind: 'hook', location: 'workspace', path: '.windsurfrules' },
+        { kind: 'mcp', location: 'machine', path: '.codeium/windsurf/mcp_config.json' },
+    ],
+    'cline': [
+        { kind: 'instructions', location: 'workspace', path: '.clinerules/brainclaw.md' },
+        { kind: 'mcp', location: 'workspace', path: '.vscode/cline_mcp_settings.json' },
+    ],
+    'codex': [
+        { kind: 'instructions', location: 'workspace', path: 'AGENTS.md' },
+        { kind: 'mcp', location: 'machine', path: '.codex/config.toml' },
+    ],
+    'opencode': [
+        { kind: 'instructions', location: 'workspace', path: 'AGENTS.md' },
+        { kind: 'mcp', location: 'workspace', path: 'opencode.json' },
+    ],
+    'antigravity': [
+        { kind: 'instructions', location: 'workspace', path: 'GEMINI.md' },
+        { kind: 'mcp', location: 'machine', path: '.gemini/antigravity/mcp_config.json' },
+    ],
+    'continue': [
+        { kind: 'instructions', location: 'workspace', path: '.continue/rules/brainclaw.md' },
+        { kind: 'mcp', location: 'workspace', path: '.continue/config.json' },
+    ],
+    'roo': [
+        { kind: 'instructions', location: 'workspace', path: '.roo/rules/brainclaw.md' },
+        { kind: 'mcp', location: 'workspace', path: '.roo/mcp.json' },
+    ],
+};
+function mergeSurfaces(current, next) {
+    const merged = [...current];
+    for (const candidate of next) {
+        const exists = merged.some((surface) => surface.kind === candidate.kind
+            && surface.location === candidate.location
+            && surface.path === candidate.path);
+        if (!exists) {
+            merged.push(candidate);
+        }
+    }
+    return merged;
+}
+export function buildAgentIntegrationDeclaration(agentName, declarationSource = 'manual') {
+    return {
+        agent_name: agentName,
+        declaration_source: declarationSource,
+        surfaces: DEFAULT_SURFACES[agentName].map((surface) => ({ ...surface })),
+    };
+}
+export function isAgentIntegrationName(value) {
+    return SUPPORTED_AGENT_INTEGRATION_NAMES.has(value);
+}
+function resolveDeclaredSurfacePath(surface, cwd, env) {
+    if (!surface.path) {
+        return undefined;
+    }
+    if (surface.location === 'workspace') {
+        return path.join(cwd, surface.path);
+    }
+    const homeDir = env.HOME?.trim() || env.USERPROFILE?.trim() || os.homedir();
+    return path.join(homeDir, surface.path);
+}
+function surfaceExists(surface, cwd, env) {
+    const expectedPath = resolveDeclaredSurfacePath(surface, cwd, env);
+    return {
+        ...surface,
+        expected_path: expectedPath,
+        exists: expectedPath ? fs.existsSync(expectedPath) : false,
+    };
+}
+export function assessAgentIntegrationReadiness(config, cwd, env = process.env) {
+    return (config.agent_integrations?.declarations ?? []).map((declaration) => {
+        const surfaces = declaration.surfaces.map((surface) => surfaceExists(surface, cwd, env));
+        const missingSurfaces = surfaces.filter((surface) => !surface.exists);
+        return {
+            agent_name: declaration.agent_name,
+            declaration_source: declaration.declaration_source,
+            ready: missingSurfaces.length === 0,
+            missing_surfaces: missingSurfaces,
+            surfaces,
+        };
+    });
+}
+export function upsertAgentIntegrationDeclaration(config, agentName, declarationSource = 'manual') {
+    const declarations = config.agent_integrations?.declarations ?? [];
+    const existing = declarations.find((item) => item.agent_name === agentName);
+    const next = buildAgentIntegrationDeclaration(agentName, declarationSource);
+    if (!config.agent_integrations) {
+        config.agent_integrations = { declarations: [] };
+    }
+    if (!existing) {
+        config.agent_integrations.declarations.push(next);
+        return true;
+    }
+    const mergedSurfaces = mergeSurfaces(existing.surfaces ?? [], next.surfaces);
+    const mergedSource = existing.declaration_source === 'manual' || declarationSource === 'manual'
+        ? 'manual'
+        : 'detected';
+    const changed = mergedSource !== existing.declaration_source
+        || mergedSurfaces.length !== (existing.surfaces?.length ?? 0);
+    existing.declaration_source = mergedSource;
+    existing.surfaces = mergedSurfaces;
+    return changed;
+}
+//# sourceMappingURL=agent-integrations.js.map

package/dist/core/agent-inventory.js

@@ -0,0 +1,401 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawnSync } from 'node:child_process';
+import yaml from 'yaml';
+import { MEMORY_DIR } from './io.js';
+function tryCommand(command, args, timeout = 5000) {
+    try {
+        const r = spawnSync(command, args, { encoding: 'utf-8', timeout, windowsHide: true });
+        return { ok: r.status === 0, stdout: r.stdout ?? '' };
+    }
+    catch {
+        return { ok: false, stdout: '' };
+    }
+}
+const AGENT_DEFINITIONS = [
+    {
+        name: 'claude-code',
+        detect: (_home, env) => {
+            // Check if claude CLI is available
+            const cli = tryCommand('claude', ['--version'], 3000);
+            if (cli.ok) {
+                const ver = cli.stdout.trim().match(/(\d+\.\d+\.\d+)/)?.[1];
+                return { installed: true, method: 'claude CLI', version: ver };
+            }
+            // Check env var (means it's running)
+            if (env.CLAUDE_CODE_VERSION) {
+                return { installed: true, method: 'CLAUDE_CODE_VERSION env', version: env.CLAUDE_CODE_VERSION };
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-opus-4-6', context_window: 1000000 },
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+            { name: 'claude-haiku-4-5', context_window: 200000 },
+        ],
+        native_tools: ['Read', 'Write', 'Edit', 'Bash', 'Glob', 'Grep', 'Agent', 'WebSearch', 'WebFetch', 'NotebookEdit'],
+        mcp_support: true,
+        mcp_config_format: '.mcp.json (workspace)',
+        skills_support: true,
+        skills_path_pattern: '.claude/commands/',
+        rules_support: false,
+        hooks_support: true,
+        instruction_file: 'CLAUDE.md',
+    },
+    {
+        name: 'cursor',
+        detect: (home) => {
+            // Check for Cursor config directories
+            const cursorDir = path.join(home, '.cursor');
+            if (fs.existsSync(cursorDir)) {
+                return { installed: true, method: '~/.cursor directory' };
+            }
+            // Check common install paths
+            if (process.platform === 'win32') {
+                const appData = process.env.LOCALAPPDATA ?? '';
+                if (appData && fs.existsSync(path.join(appData, 'Programs', 'cursor'))) {
+                    return { installed: true, method: 'AppData/Programs/cursor' };
+                }
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+            { name: 'gpt-4o', context_window: 128000 },
+            { name: 'cursor-small', context_window: 128000 },
+        ],
+        native_tools: ['edit', 'terminal', 'codebase-search', 'file-search'],
+        mcp_support: true,
+        mcp_config_format: '.cursor/mcp.json (machine)',
+        skills_support: false,
+        rules_support: true,
+        hooks_support: false,
+        instruction_file: '.cursor/rules/',
+    },
+    {
+        name: 'codex',
+        detect: (home) => {
+            const codexDir = path.join(home, '.codex');
+            if (fs.existsSync(codexDir)) {
+                return { installed: true, method: '~/.codex directory' };
+            }
+            const cli = tryCommand('codex', ['--version'], 3000);
+            if (cli.ok) {
+                const ver = cli.stdout.trim().match(/(\d+\.\d+\.\d+)/)?.[1];
+                return { installed: true, method: 'codex CLI', version: ver };
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'o4-mini', context_window: 200000 },
+            { name: 'o3', context_window: 200000 },
+            { name: 'gpt-4.1', context_window: 1000000 },
+        ],
+        native_tools: ['shell', 'file_read', 'file_write', 'file_edit'],
+        mcp_support: true,
+        mcp_config_format: '.codex/config.toml (TOML)',
+        skills_support: true,
+        skills_path_pattern: '.codex/skills/',
+        rules_support: false,
+        hooks_support: false,
+        instruction_file: 'AGENTS.md',
+    },
+    {
+        name: 'windsurf',
+        detect: (home) => {
+            if (process.platform === 'win32') {
+                const appData = process.env.LOCALAPPDATA ?? '';
+                if (appData && fs.existsSync(path.join(appData, 'Programs', 'windsurf'))) {
+                    return { installed: true, method: 'AppData/Programs/windsurf' };
+                }
+            }
+            // Check for Windsurf config
+            const wsConfig = path.join(home, '.codeium', 'windsurf');
+            if (fs.existsSync(wsConfig)) {
+                return { installed: true, method: '~/.codeium/windsurf directory' };
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+            { name: 'gpt-4o', context_window: 128000 },
+        ],
+        native_tools: ['edit', 'terminal', 'search'],
+        mcp_support: true,
+        mcp_config_format: '.codeium/windsurf/mcp_config.json',
+        skills_support: false,
+        rules_support: true,
+        hooks_support: true,
+        instruction_file: '.windsurfrules',
+    },
+    {
+        name: 'github-copilot',
+        detect: (_home, env) => {
+            if (env.GITHUB_COPILOT_TOKEN || env.GITHUB_COPILOT_PRODUCT) {
+                return { installed: true, method: 'GITHUB_COPILOT_* env' };
+            }
+            // Check VS Code extensions directory for copilot
+            const vscodeExt = path.join(_home, '.vscode', 'extensions');
+            if (fs.existsSync(vscodeExt)) {
+                try {
+                    const exts = fs.readdirSync(vscodeExt);
+                    if (exts.some(e => e.startsWith('github.copilot-'))) {
+                        return { installed: true, method: 'VS Code extension' };
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'gpt-4o', context_window: 128000 },
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+        ],
+        native_tools: ['code-completion', 'chat', 'inline-edit'],
+        mcp_support: false,
+        skills_support: true,
+        skills_path_pattern: '.github/skills/',
+        rules_support: false,
+        hooks_support: false,
+        instruction_file: '.github/copilot-instructions.md',
+    },
+    {
+        name: 'cline',
+        detect: (_home, env) => {
+            if (env.CLINE_AGENT || env.CLINE_SESSION_ID) {
+                return { installed: true, method: 'CLINE_* env' };
+            }
+            const vscodeExt = path.join(_home, '.vscode', 'extensions');
+            if (fs.existsSync(vscodeExt)) {
+                try {
+                    const exts = fs.readdirSync(vscodeExt);
+                    if (exts.some(e => e.includes('cline'))) {
+                        return { installed: true, method: 'VS Code extension' };
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+            { name: 'gpt-4o', context_window: 128000 },
+        ],
+        native_tools: ['read_file', 'write_file', 'execute_command', 'browser_action', 'search_files'],
+        mcp_support: true,
+        mcp_config_format: '.vscode/cline_mcp_settings.json',
+        skills_support: false,
+        rules_support: true,
+        hooks_support: false,
+        instruction_file: '.clinerules/',
+    },
+    {
+        name: 'roo',
+        detect: (_home, env) => {
+            if (env.ROO_AGENT || env.ROO_SESSION_ID) {
+                return { installed: true, method: 'ROO_* env' };
+            }
+            const vscodeExt = path.join(_home, '.vscode', 'extensions');
+            if (fs.existsSync(vscodeExt)) {
+                try {
+                    const exts = fs.readdirSync(vscodeExt);
+                    if (exts.some(e => e.includes('roo'))) {
+                        return { installed: true, method: 'VS Code extension' };
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+        ],
+        native_tools: ['read_file', 'write_file', 'execute_command', 'browser_action', 'search_files'],
+        mcp_support: true,
+        mcp_config_format: '.roo/mcp.json',
+        skills_support: false,
+        rules_support: true,
+        hooks_support: false,
+        instruction_file: '.roo/rules/',
+    },
+    {
+        name: 'opencode',
+        detect: (home, env) => {
+            if (env.OPENCODE_SESSION_ID || env.OPENCODE_AGENT) {
+                return { installed: true, method: 'OPENCODE_* env' };
+            }
+            if (fs.existsSync(path.join(home, '.config', 'opencode'))) {
+                return { installed: true, method: '~/.config/opencode directory' };
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+            { name: 'gpt-4o', context_window: 128000 },
+        ],
+        native_tools: ['file_read', 'file_write', 'shell', 'search'],
+        mcp_support: true,
+        mcp_config_format: 'opencode.json',
+        skills_support: false,
+        rules_support: false,
+        hooks_support: false,
+        instruction_file: 'AGENTS.md',
+    },
+    {
+        name: 'antigravity',
+        detect: (home, env) => {
+            if (env.ANTIGRAVITY_SESSION_ID || env.ANTIGRAVITY_AGENT) {
+                return { installed: true, method: 'ANTIGRAVITY_* env' };
+            }
+            if (fs.existsSync(path.join(home, '.gemini', 'antigravity'))) {
+                return { installed: true, method: '~/.gemini/antigravity directory' };
+            }
+            const cli = tryCommand('gemini', ['--version'], 3000);
+            if (cli.ok) {
+                return { installed: true, method: 'gemini CLI', version: cli.stdout.trim() };
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'gemini-2.5-pro', context_window: 1000000 },
+            { name: 'gemini-2.5-flash', context_window: 1000000 },
+        ],
+        native_tools: ['shell', 'file_read', 'file_write', 'file_edit', 'web_search'],
+        mcp_support: true,
+        mcp_config_format: '.gemini/antigravity/mcp_config.json',
+        skills_support: false,
+        rules_support: false,
+        hooks_support: false,
+        instruction_file: 'GEMINI.md',
+    },
+    {
+        name: 'continue',
+        detect: (_home, env) => {
+            if (env.CONTINUE_AGENT || env.CONTINUE_SESSION_ID) {
+                return { installed: true, method: 'CONTINUE_* env' };
+            }
+            const vscodeExt = path.join(_home, '.vscode', 'extensions');
+            if (fs.existsSync(vscodeExt)) {
+                try {
+                    const exts = fs.readdirSync(vscodeExt);
+                    if (exts.some(e => e.includes('continue'))) {
+                        return { installed: true, method: 'VS Code extension' };
+                    }
+                }
+                catch { /* non-fatal */ }
+            }
+            return { installed: false, method: '' };
+        },
+        models: [
+            { name: 'claude-sonnet-4-6', context_window: 200000 },
+            { name: 'gpt-4o', context_window: 128000 },
+        ],
+        native_tools: ['edit', 'terminal', 'codebase-search'],
+        mcp_support: true,
+        mcp_config_format: '.continue/config.json',
+        skills_support: false,
+        rules_support: true,
+        hooks_support: false,
+        instruction_file: '.continue/rules/',
+    },
+];
+// ── Public API ─────────────────────────────────────────────────────────────────
+/**
+ * Detect ALL installed agents on this machine (not just the running one).
+ */
+export function buildAgentInventory(homeDir = os.homedir(), env = process.env) {
+    const agents = AGENT_DEFINITIONS.map(def => {
+        const detection = def.detect(homeDir, env);
+        return {
+            name: def.name,
+            installed: detection.installed,
+            detection_method: detection.method,
+            version: detection.version,
+            models: def.models,
+            native_tools: def.native_tools,
+            mcp_support: def.mcp_support,
+            mcp_config_format: def.mcp_config_format,
+            skills_support: def.skills_support,
+            skills_path_pattern: def.skills_path_pattern,
+            rules_support: def.rules_support,
+            hooks_support: def.hooks_support,
+            instruction_file: def.instruction_file,
+        };
+    });
+    return {
+        schema_version: 1,
+        generated_at: new Date().toISOString(),
+        agents,
+    };
+}
+/**
+ * Path to the agent inventory file.
+ */
+export function agentInventoryPath() {
+    return path.join(os.homedir(), MEMORY_DIR, 'agents-inventory.yaml');
+}
+/**
+ * Save agent inventory to ~/.brainclaw/agents-inventory.yaml.
+ */
+export function saveAgentInventory(inventory) {
+    const filePath = agentInventoryPath();
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const content = yaml.stringify(inventory, { lineWidth: 120 });
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return filePath;
+}
+/**
+ * Load agent inventory from ~/.brainclaw/agents-inventory.yaml.
+ */
+export function loadAgentInventory() {
+    const filePath = agentInventoryPath();
+    if (!fs.existsSync(filePath))
+        return undefined;
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return yaml.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * Render a human-readable summary of the agent inventory.
+ */
+export function renderAgentInventorySummary(inventory) {
+    const lines = [];
+    const installed = inventory.agents.filter(a => a.installed);
+    const notInstalled = inventory.agents.filter(a => !a.installed);
+    lines.push(`Agents detected: ${installed.length}/${inventory.agents.length}`);
+    lines.push('');
+    for (const agent of installed) {
+        const ver = agent.version ? ` v${agent.version}` : '';
+        lines.push(`✔ ${agent.name}${ver} (${agent.detection_method})`);
+        lines.push(`  Models: ${agent.models.map(m => m.name).join(', ')}`);
+        lines.push(`  Tools: ${agent.native_tools.join(', ')}`);
+        const features = [];
+        if (agent.mcp_support)
+            features.push('MCP');
+        if (agent.skills_support)
+            features.push('Skills');
+        if (agent.rules_support)
+            features.push('Rules');
+        if (agent.hooks_support)
+            features.push('Hooks');
+        lines.push(`  Features: ${features.join(', ') || 'none'}`);
+        if (agent.instruction_file) {
+            lines.push(`  Instructions: ${agent.instruction_file}`);
+        }
+        lines.push('');
+    }
+    if (notInstalled.length > 0) {
+        lines.push(`Not detected: ${notInstalled.map(a => a.name).join(', ')}`);
+    }
+    lines.push(`Inventory generated: ${inventory.generated_at}`);
+    return lines.join('\n');
+}
+//# sourceMappingURL=agent-inventory.js.map