@kinqs/brainrouter-cli 0.3.4

package/dist/config/config.d.ts

@@ -0,0 +1,22 @@
+export interface ServerConfig {
+    type: 'stdio' | 'http';
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    apiKey?: string;
+}
+export interface LLMConfig {
+    provider: 'openai';
+    apiKey: string;
+    model: string;
+    endpoint?: string;
+}
+export interface Config {
+    activeServer: string;
+    servers: Record<string, ServerConfig>;
+    llm?: LLMConfig;
+}
+export declare function getConfigPath(): string;
+export declare function loadConfig(): Config;
+export declare function saveConfig(config: Config): void;

package/dist/config/config.js

@@ -0,0 +1,105 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { DatabaseSync } from 'node:sqlite';
+const CONFIG_DIR = path.join(os.homedir(), '.config', 'brainrouter');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'config.json');
+export function getConfigPath() {
+    return CONFIG_FILE;
+}
+export function loadConfig() {
+    let config;
+    if (!fs.existsSync(CONFIG_FILE)) {
+        config = createDefaultConfig();
+    }
+    else {
+        try {
+            const raw = fs.readFileSync(CONFIG_FILE, 'utf8');
+            const parsed = JSON.parse(raw);
+            // Backfill standard properties if missing
+            if (!parsed.servers)
+                parsed.servers = {};
+            if (!parsed.activeServer)
+                parsed.activeServer = 'default';
+            config = parsed;
+        }
+        catch (error) {
+            console.error(`Warning: Failed to parse config file at ${CONFIG_FILE}. Using default config.`);
+            config = createDefaultConfig();
+        }
+    }
+    // Auto-resolve placeholder API keys if possible
+    resolveDefaultApiKey(config);
+    // The default config writes `llm.apiKey: ''` so it never appears as a
+    // secret in the committed file. Backfill from the standard env vars at
+    // load time so every downstream consumer (callOpenAI, mcpClient env
+    // propagation, the cognitive extractor LLM runner) sees a real value
+    // instead of the empty string.
+    if (config.llm && !config.llm.apiKey.trim()) {
+        const envKey = process.env.OPENAI_API_KEY || process.env.BRAINROUTER_LLM_API_KEY;
+        if (envKey)
+            config.llm.apiKey = envKey;
+    }
+    return config;
+}
+export function saveConfig(config) {
+    try {
+        if (!fs.existsSync(CONFIG_DIR)) {
+            fs.mkdirSync(CONFIG_DIR, { recursive: true });
+        }
+        fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2), 'utf8');
+    }
+    catch (error) {
+        console.error(`Error: Failed to save config to ${CONFIG_FILE}:`, error instanceof Error ? error.message : error);
+    }
+}
+function createDefaultConfig() {
+    // Derive path to the default local MCP server dist relative to this module.
+    // After build: brainrouter-cli/dist/config/config.js → walk three levels up
+    // to the monorepo root, then into the sibling `brainrouter/` package
+    // (formerly `mcp/`) which is the MCP server.
+    const defaultMcpPath = path.resolve(import.meta.dirname, '..', '..', '..', 'brainrouter', 'dist', 'index.js');
+    const config = {
+        activeServer: 'default',
+        servers: {
+            default: {
+                type: 'stdio',
+                command: 'node',
+                args: [defaultMcpPath, '--root', './'],
+                env: {
+                    BRAINROUTER_API_KEY: 'br_admin_key_placeholder'
+                }
+            }
+        },
+        llm: {
+            provider: 'openai',
+            apiKey: '',
+            model: 'gpt-4o-mini',
+            endpoint: 'https://api.openai.com/v1'
+        }
+    };
+    saveConfig(config);
+    return config;
+}
+function resolveDefaultApiKey(config) {
+    const defaultServer = config.servers.default;
+    if (defaultServer &&
+        defaultServer.type === 'stdio' &&
+        defaultServer.env &&
+        defaultServer.env.BRAINROUTER_API_KEY === 'br_admin_key_placeholder') {
+        const dbPath = process.env.BRAINROUTER_MEMORY_DB || path.join(os.homedir(), '.brainrouter', 'memory.db');
+        if (fs.existsSync(dbPath)) {
+            try {
+                const db = new DatabaseSync(dbPath);
+                const row = db.prepare("SELECT api_key FROM users WHERE is_admin = 1 LIMIT 1").get();
+                if (row && row.api_key) {
+                    defaultServer.env.BRAINROUTER_API_KEY = row.api_key;
+                    saveConfig(config);
+                }
+            }
+            catch (error) {
+                // ignore errors
+            }
+        }
+    }
+}

package/dist/config/workspace.d.ts

@@ -0,0 +1,7 @@
+export interface WorkspaceInfo {
+    launchCwd: string;
+    workspaceRoot: string;
+    reason: string;
+}
+export declare function findWorkspaceRoot(startDir?: string): WorkspaceInfo;
+export declare function applyWorkspaceRoot(workspaceRoot: string): void;

package/dist/config/workspace.js

@@ -0,0 +1,62 @@
+import fs from 'node:fs';
+import path from 'node:path';
+const ROOT_MARKERS = ['AGENT.md', 'AGENTS.md', '.git'];
+export function findWorkspaceRoot(startDir = process.cwd()) {
+    const launchCwd = fs.realpathSync(startDir);
+    const envRoot = process.env.BRAINROUTER_WORKSPACE;
+    if (envRoot) {
+        return {
+            launchCwd,
+            workspaceRoot: fs.realpathSync(path.resolve(envRoot)),
+            reason: 'BRAINROUTER_WORKSPACE',
+        };
+    }
+    const markerRoot = findNearestMarkerRoot(launchCwd);
+    if (markerRoot) {
+        const monorepoRoot = maybePromoteBrainRouterPackage(markerRoot);
+        return {
+            launchCwd,
+            workspaceRoot: monorepoRoot.root,
+            reason: monorepoRoot.reason,
+        };
+    }
+    return {
+        launchCwd,
+        workspaceRoot: launchCwd,
+        reason: 'cwd',
+    };
+}
+export function applyWorkspaceRoot(workspaceRoot) {
+    process.chdir(workspaceRoot);
+}
+function findNearestMarkerRoot(startDir) {
+    let current = startDir;
+    while (true) {
+        if (ROOT_MARKERS.some(marker => fs.existsSync(path.join(current, marker)))) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current)
+            return undefined;
+        current = parent;
+    }
+}
+function maybePromoteBrainRouterPackage(root) {
+    const parent = path.dirname(root);
+    const packageJsonPath = path.join(parent, 'package.json');
+    if (path.basename(root) === 'brainrouter-cli' &&
+        fs.existsSync(path.join(parent, 'AGENT.md')) &&
+        fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+            const workspaces = Array.isArray(packageJson.workspaces) ? packageJson.workspaces : [];
+            if (workspaces.includes('brainrouter-cli') || workspaces.includes('brainrouter-cli/*')) {
+                return { root: fs.realpathSync(parent), reason: 'parent monorepo workspace' };
+            }
+        }
+        catch {
+            // Keep the original marker root if package.json is unreadable.
+        }
+    }
+    return { root, reason: 'nearest workspace marker' };
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};