@ekkos/cli 1.3.8 → 1.4.0

package/dist/commands/gemini.d.ts

@@ -12,6 +12,7 @@ export interface GeminiOptions {
     verbose?: boolean;
     noProxy?: boolean;
     session?: string;
+    dashboard?: boolean;
 }
 /**
  * Launch Gemini CLI with ekkOS proxy integration.

package/dist/commands/gemini.js

@@ -62,6 +62,8 @@ const isWindows = process.platform === 'win32';
 const PULSE_LOADED_TEXT = '  🧠 ekkOS_Pulse  Loaded!';
 const PULSE_SHINE_FRAME_MS = 50;
 const PULSE_SHINE_SWEEPS = 2;
+const GEMINI_DEFAULT_MODEL = 'gemini-3.1-flash-lite-preview';
+const GEMINI_MAX_OUTPUT_TOKENS = 65536;
 function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
@@ -94,9 +96,18 @@ async function showPulseLoadedBanner() {
 }
 /**
  * Resolve Gemini CLI binary path.
- * Checks common locations then falls back to PATH lookup.
+ * Checks PATH first (which/where), then falls back to common locations.
  */
 function resolveGeminiPath() {
+    // 1. PATH lookup first to respect nvm/volta/npm-global settings
+    const whichCmd = isWindows ? 'where gemini' : 'which gemini';
+    try {
+        const result = (0, child_process_1.execSync)(whichCmd, { encoding: 'utf-8', stdio: 'pipe' }).trim();
+        if (result)
+            return result.split('\n')[0];
+    }
+    catch { /* not found in PATH */ }
+    // 2. Fallback to common global install locations
     if (!isWindows) {
         const pathsToCheck = [
             '/opt/homebrew/bin/gemini',
@@ -109,16 +120,161 @@ function resolveGeminiPath() {
                 return p;
         }
     }
-    // PATH lookup
-    const whichCmd = isWindows ? 'where gemini' : 'which gemini';
+    // 3. Ultimate fallback — let spawn resolve it (will error with helpful message)
+    return 'gemini';
+}
+function extractGeminiCliArgs() {
+    const geminiIdx = process.argv.indexOf('gemini');
+    if (geminiIdx === -1)
+        return [];
+    const rawArgs = process.argv.slice(geminiIdx + 1);
+    const filtered = [];
+    for (let i = 0; i < rawArgs.length; i += 1) {
+        const arg = rawArgs[i];
+        if (!arg)
+            continue;
+        if (arg === '--skip-proxy' || arg === '-v' || arg === '--verbose' || arg === '--dashboard') {
+            continue;
+        }
+        if (arg === '-s' || arg === '--session') {
+            i += 1;
+            continue;
+        }
+        filtered.push(arg);
+    }
+    return filtered;
+}
+function resolveGeminiLaunchModel(args) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = args[i];
+        if (!arg)
+            continue;
+        if ((arg === '-m' || arg === '--model') && typeof args[i + 1] === 'string') {
+            return args[i + 1];
+        }
+        if (arg.startsWith('--model=')) {
+            const value = arg.slice('--model='.length).trim();
+            if (value)
+                return value;
+        }
+    }
+    const envModel = (process.env.GEMINI_MODEL || process.env.GOOGLE_GEMINI_MODEL || '').trim();
+    return envModel || GEMINI_DEFAULT_MODEL;
+}
+function resolveGeminiContextSize(model) {
+    const normalized = (model || '').trim().toLowerCase();
+    if (normalized.startsWith('gemini-3.1-pro') || normalized.startsWith('gemini-3-pro')) {
+        return 2097152;
+    }
+    return 1048576;
+}
+function resolveGeminiProjectId(projectPath) {
     try {
-        const result = (0, child_process_1.execSync)(whichCmd, { encoding: 'utf-8', stdio: 'pipe' }).trim();
-        if (result)
-            return result.split('\n')[0];
+        const projectsPath = path.join(os.homedir(), '.gemini', 'projects.json');
+        if (!fs.existsSync(projectsPath))
+            return undefined;
+        const parsed = JSON.parse(fs.readFileSync(projectsPath, 'utf-8'));
+        const projectId = parsed?.projects?.[projectPath];
+        return typeof projectId === 'string' && projectId.length > 0 ? projectId : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function getGeminiSessionMetadata(options, args) {
+    const model = resolveGeminiLaunchModel(args);
+    return {
+        provider: 'gemini',
+        claudeModel: model,
+        claudeLaunchModel: model,
+        claudeContextWindow: '1m',
+        claudeContextSize: resolveGeminiContextSize(model),
+        claudeMaxOutputTokens: GEMINI_MAX_OUTPUT_TOKENS,
+        geminiProjectId: resolveGeminiProjectId(process.cwd()),
+        dashboardEnabled: options.dashboard === true,
+    };
+}
+function writeGeminiSessionFiles(sessionId, sessionName, metadata) {
+    try {
+        const ekkosDir = path.join(os.homedir(), '.ekkos');
+        if (!fs.existsSync(ekkosDir))
+            fs.mkdirSync(ekkosDir, { recursive: true });
+        const now = new Date().toISOString();
+        fs.writeFileSync(path.join(ekkosDir, 'current-session.json'), JSON.stringify({ session_id: sessionId, session_name: sessionName, timestamp: now, ...metadata }, null, 2));
+        fs.writeFileSync(path.join(ekkosDir, 'session-hint.json'), JSON.stringify({
+            session_id: sessionId,
+            session_name: sessionName,
+            project_path: process.cwd(),
+            timestamp: now,
+            pid: process.pid,
+            ...metadata,
+        }, null, 2));
+    }
+    catch {
+        // Non-fatal
+    }
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\"'\"'`)}'`;
+}
+function launchGeminiWithDashboard(options, extraArgs) {
+    (0, state_1.getActiveSessions)();
+    const tmuxSession = `ekkos-gemini-${Date.now().toString(36)}`;
+    const sessionName = options.session || (0, state_1.uuidToWords)(crypto.randomUUID());
+    const sessionId = crypto.randomUUID();
+    options.session = sessionName;
+    cliSessionName = sessionName;
+    cliSessionId = sessionId;
+    const metadata = getGeminiSessionMetadata({ ...options, session: sessionName, dashboard: true }, extraArgs);
+    const ekkosCmd = process.argv[1];
+    const cwd = process.cwd();
+    const termCols = process.stdout.columns ?? 160;
+    const termRows = process.stdout.rows ?? 48;
+    writeGeminiSessionFiles(sessionId, sessionName, metadata);
+    const geminiArgs = ['gemini', '-s', sessionName];
+    if (options.verbose)
+        geminiArgs.push('-v');
+    if (options.noProxy)
+        geminiArgs.push('--skip-proxy');
+    geminiArgs.push(...extraArgs);
+    const runCommand = `EKKOS_NO_SPLASH=1 node ${shellQuote(ekkosCmd)} ${geminiArgs.map(shellQuote).join(' ')}`;
+    const dashCommand = `node ${shellQuote(ekkosCmd)} dashboard ${shellQuote(sessionName)} --provider gemini --refresh 2000`;
+    try {
+        (0, child_process_1.execSync)(`tmux new-session -d -s "${tmuxSession}" -x ${termCols} -y ${termRows} -n "gemini" 'sleep 86400'`, { stdio: 'pipe' });
+        const applyTmuxOpt = (cmd) => {
+            try {
+                (0, child_process_1.execSync)(`tmux ${cmd}`, { stdio: 'pipe' });
+            }
+            catch (err) {
+                if (options.verbose) {
+                    console.log(chalk_1.default.gray(`  tmux option skipped: ${cmd} (${err.message})`));
+                }
+            }
+        };
+        applyTmuxOpt(`set-option -t "${tmuxSession}" default-terminal "xterm-256color"`);
+        applyTmuxOpt(`set-option -sa -t "${tmuxSession}" terminal-overrides ",xterm-256color:Tc:smcup@:rmcup@"`);
+        applyTmuxOpt(`set-option -t "${tmuxSession}" mouse on`);
+        const detachCleanupHook = `if-shell -F '#{==:#{session_attached},0}' 'kill-session -t ${tmuxSession}'`;
+        applyTmuxOpt(`set-hook -t "${tmuxSession}" client-detached "${detachCleanupHook}"`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}" history-limit 100000`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}" mode-keys vi`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}:gemini" synchronize-panes off`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}:gemini" window-size latest`);
+        applyTmuxOpt(`set-window-option -t "${tmuxSession}:gemini" aggressive-resize on`);
+        applyTmuxOpt(`set-option -t "${tmuxSession}" remain-on-exit off`);
+        applyTmuxOpt(`set-option -t "${tmuxSession}" escape-time 0`);
+        (0, child_process_1.execSync)(`tmux split-window -t "${tmuxSession}:gemini" -h -p 40 -c "${cwd}" ${shellQuote(dashCommand)}`, { stdio: 'pipe' });
+        (0, child_process_1.execSync)(`tmux respawn-pane -k -t "${tmuxSession}:gemini.0" ${shellQuote(runCommand)}`, { stdio: 'pipe' });
+        (0, child_process_1.execSync)(`tmux select-pane -t "${tmuxSession}:gemini.0"`, { stdio: 'pipe' });
+        (0, child_process_1.execSync)(`tmux attach -t "${tmuxSession}"`, { stdio: 'inherit' });
+        return true;
+    }
+    catch (err) {
+        console.error(chalk_1.default.red(`\n  ✘ Failed to launch Gemini dashboard split: ${err.message}\n`));
+        console.log(chalk_1.default.gray('  Falling back to normal Gemini mode.'));
+        console.log(chalk_1.default.gray('  Run "ekkos dashboard --latest --provider gemini" in another terminal.\n'));
+        return false;
     }
-    catch { /* not found */ }
-    // Fallback — let spawn resolve it (will error with helpful message)
-    return 'gemini';
 }
 /**
  * Build environment for Gemini CLI with proxy routing.
@@ -137,14 +293,20 @@ function buildGeminiEnv(options) {
     // Resolve userId from config or auth token
     const ekkosConfig = (0, state_1.getConfig)();
     let userId = ekkosConfig?.userId || 'anonymous';
+    const authToken = (0, state_1.getAuthToken)();
     if (userId === 'anonymous') {
-        const authToken = (0, state_1.getAuthToken)();
         if (authToken?.startsWith('ekk_')) {
             const parts = authToken.split('_');
             if (parts.length >= 2 && parts[1])
                 userId = parts[1];
         }
     }
+    // Gemini CLI strictly requires an API key to exist in the environment,
+    // even when routing to a proxy. If they don't have GEMINI_API_KEY set, 
+    // provide their GOOGLE_AI_API_KEY, ekkOS auth token, or a placeholder so the CLI boots up.
+    if (!env.GEMINI_API_KEY) {
+        env.GEMINI_API_KEY = env.GOOGLE_AI_API_KEY || authToken || 'ekk_guest_token_for_proxy';
+    }
     // Build proxy URL — no query params (SDK concatenates baseUrl + path as strings).
     // Format: /gproxy/{userId}/{session}/{sid}/{project64}
     // Proxy extracts params from path, then routes /v1beta or /v1beta1 to googleRouter.
@@ -163,6 +325,11 @@ function buildGeminiEnv(options) {
  */
 async function gemini(options = {}) {
     (0, state_1.ensureEkkosDir)();
+    const extraArgs = extractGeminiCliArgs();
+    if (options.dashboard) {
+        if (launchGeminiWithDashboard(options, extraArgs))
+            return;
+    }
     console.log('');
     console.log(chalk_1.default.cyan('  🧠 ekkOS_') + chalk_1.default.gray(' + ') + chalk_1.default.blue('Gemini CLI'));
     // Resolve binary
@@ -175,7 +342,9 @@ async function gemini(options = {}) {
     // Register session for multi-session awareness
     const sessionId = cliSessionId || crypto.randomUUID();
     const sessionName = cliSessionName || 'gemini-session';
-    (0, state_1.registerActiveSession)(sessionId, sessionName, process.cwd());
+    const metadata = getGeminiSessionMetadata(options, extraArgs);
+    (0, state_1.registerActiveSession)(sessionId, sessionName, process.cwd(), metadata);
+    writeGeminiSessionFiles(sessionId, sessionName, metadata);
     if (!options.noProxy) {
         await showPulseLoadedBanner();
     }
@@ -183,14 +352,6 @@ async function gemini(options = {}) {
     // Extract any trailing arguments meant for the inner CLI
     // We look for 'gemini' in process.argv and pass everything after it.
     // If the user did `ekkos gemini -m gemini-3.1-pro-preview`, we want to pass `-m gemini-3.1-pro-preview`
-    let extraArgs = [];
-    const geminiIdx = process.argv.indexOf('gemini');
-    if (geminiIdx !== -1) {
-        extraArgs = process.argv.slice(geminiIdx + 1).filter(a => {
-            // Filter out ekkos wrapper options
-            return !['--skip-proxy', '-v', '--verbose'].includes(a) && !(a === '-s' || a === '--session' || process.argv[process.argv.indexOf(a) - 1] === '-s' || process.argv[process.argv.indexOf(a) - 1] === '--session');
-        });
-    }
     // Spawn Gemini CLI — stdio: inherit for full terminal passthrough
     const child = (0, child_process_1.spawn)(geminiPath, extraArgs, {
         stdio: 'inherit',

package/dist/commands/init-living-docs.d.ts

@@ -0,0 +1,6 @@
+export interface InitLivingDocsOptions {
+    path?: string;
+    timeZone?: string;
+    noSeed?: boolean;
+}
+export declare function initLivingDocs(options: InitLivingDocsOptions): Promise<void>;

package/dist/commands/init-living-docs.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.initLivingDocs = initLivingDocs;
+const chalk_1 = __importDefault(require("chalk"));
+const path_1 = require("path");
+const living_docs_manager_js_1 = require("../local/living-docs-manager.js");
+const state_1 = require("../utils/state");
+const platform_js_1 = require("../utils/platform.js");
+async function initLivingDocs(options) {
+    const targetPath = (0, path_1.resolve)(options.path || process.cwd());
+    const timeZone = options.timeZone || process.env.EKKOS_USER_TIMEZONE || Intl.DateTimeFormat().resolvedOptions().timeZone;
+    const apiKey = options.noSeed ? null : (0, state_1.getAuthToken)();
+    const apiUrl = options.noSeed ? undefined : (process.env.EKKOS_API_URL || platform_js_1.MCP_API_URL);
+    console.log('\n  ' + chalk_1.default.cyan.bold('Initialize ekkOS Cortex'));
+    console.log(chalk_1.default.gray('  ─────────────────────────────────'));
+    console.log(chalk_1.default.gray(`  Path: ${targetPath}`));
+    const manager = new living_docs_manager_js_1.LocalLivingDocsManager({
+        targetPath,
+        apiUrl,
+        apiKey,
+        timeZone,
+        onLog: message => console.log(chalk_1.default.gray(`  ${message}`)),
+    });
+    // Force a full scan and compile by ignoring the cooldown
+    // We'll use a slightly different flow than .start() to make it one-shot
+    console.log(chalk_1.default.gray('  Scanning repository structure...'));
+    // We hack the cooldown by temporarily setting the env var if we could, 
+    // but better to just call the internal methods if they were public.
+    // Since they are private, we'll use a small trick: 
+    // The start() method is what we want, but we want it to exit after the first pass.
+    // Actually, let's just use start() and wait for the initialCompilePromise
+    manager.start();
+    // Give it a moment to start the initial pass
+    const checkInterval = setInterval(() => {
+        // @ts-ignore - reaching into private for the promise
+        if (manager.initialCompilePromise) {
+            // @ts-ignore
+            manager.initialCompilePromise.then(() => {
+                clearInterval(checkInterval);
+                manager.stop();
+                console.log('\n' + chalk_1.default.green('  ✓ ekkOS Cortex initialized successfully!'));
+                console.log(chalk_1.default.gray('  Your project now has ekkOS_CONTEXT.md files for every discovered system.'));
+                console.log(chalk_1.default.gray('  Run `ekkos cortex watch` to keep them updated while you work.'));
+                console.log('');
+                process.exit(0);
+            });
+        }
+    }, 100);
+    // Safety timeout
+    setTimeout(() => {
+        console.log(chalk_1.default.red('\n  Initialization timed out.'));
+        process.exit(1);
+    }, 60000);
+}

package/dist/commands/living-docs.js

@@ -11,13 +11,13 @@ const state_1 = require("../utils/state");
 const platform_js_1 = require("../utils/platform.js");
 function printStartupSummary(options) {
     console.log('');
-    console.log(chalk_1.default.cyan.bold('  ekkOS Living Docs Watch'));
-    console.log(chalk_1.default.gray('  ─────────────────────────'));
+    console.log(chalk_1.default.cyan.bold('  ekkOS Cortex Watcher'));
+    console.log(chalk_1.default.gray('  ──────────────────────'));
     console.log(chalk_1.default.gray(`  Path: ${options.targetPath}`));
     console.log(chalk_1.default.gray(`  Timezone: ${options.timeZone}`));
     console.log(chalk_1.default.gray(`  Registry seed: ${options.seedingEnabled ? 'enabled' : 'disabled'}`));
     console.log('');
-    console.log(chalk_1.default.gray('  Watching local files and rewriting ekkOS_CONTEXT.md on change.'));
+    console.log(chalk_1.default.gray('  Watching local files and updating Cortex docs (ekkOS_CONTEXT.md) on change.'));
     console.log(chalk_1.default.gray('  Press Ctrl+C to stop.'));
     console.log('');
 }

package/dist/commands/run.d.ts

@@ -2,12 +2,17 @@ interface RunOptions {
     session?: string;
     verbose?: boolean;
     bypass?: boolean;
+    pulse?: boolean;
     doctor?: boolean;
     noInject?: boolean;
     research?: boolean;
     noProxy?: boolean;
     dashboard?: boolean;
     addDirs?: string[];
+    model?: string | boolean;
+    contextWindow?: string;
+    continueLast?: boolean;
+    resumeSession?: string;
     slashOpenDelayMs?: number;
     charDelayMs?: number;
     postEnterDelayMs?: number;