gemkit-cli 0.2.2 → 0.3.0

package/dist/domains/session/writer.js

@@ -0,0 +1,431 @@
+/**
+ * Session writer - WRITE operations
+ * Aligned with gk-session-manager.cjs write functions
+ *
+ * Used by:
+ * - gk session init (replaces gk-init.cjs)
+ * - gk plan set (replaces gk-set-active-plan.cjs)
+ */
+import { existsSync, mkdirSync, writeFileSync, readFileSync, renameSync, unlinkSync } from 'fs';
+import { execSync } from 'child_process';
+import { join } from 'path';
+import { getProjectDataDir, getSessionPath, getProjectPath, getLocalEnvPath, sanitizeProjectPath } from '../../utils/paths.js';
+import { generateProjectHash, generateGkSessionId } from '../../services/hash.js';
+import { readEnv } from './env.js';
+import { getSession } from './manager.js';
+/**
+ * Get parent PID and process name on Windows using CIM
+ */
+function getProcessInfoWin32(pid) {
+    try {
+        const cmd = `powershell -Command "$p = Get-CimInstance Win32_Process -Filter 'ProcessId=${pid}'; Write-Output $p.ParentProcessId; Write-Output $p.Name"`;
+        const output = execSync(cmd, { encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const lines = output.split(/\r?\n/);
+        const parentPid = parseInt(lines[0], 10);
+        const processName = lines[1] || null;
+        return {
+            parentPid: (!isNaN(parentPid) && parentPid > 0) ? parentPid : null,
+            processName: processName
+        };
+    }
+    catch {
+        return { parentPid: null, processName: null };
+    }
+}
+/**
+ * Check if a process name is a shell
+ */
+function isShellProcess(name) {
+    if (!name)
+        return false;
+    const shellNames = ['powershell.exe', 'pwsh.exe', 'cmd.exe', 'bash.exe', 'zsh.exe', 'sh.exe', 'fish.exe'];
+    return shellNames.includes(name.toLowerCase());
+}
+/**
+ * Check if a process name is an IDE/terminal host
+ */
+function isIDEProcess(name) {
+    if (!name)
+        return false;
+    const lowerName = name.toLowerCase();
+    const ideNames = [
+        'code.exe', 'code - insiders.exe',
+        'cursor.exe', 'windsurf.exe', 'positron.exe',
+        'idea64.exe', 'idea.exe', 'webstorm64.exe', 'webstorm.exe',
+        'pycharm64.exe', 'pycharm.exe', 'phpstorm64.exe', 'phpstorm.exe',
+        'goland64.exe', 'goland.exe', 'rustrover64.exe', 'rustrover.exe',
+        'rider64.exe', 'rider.exe', 'clion64.exe', 'clion.exe',
+        'datagrip64.exe', 'datagrip.exe', 'fleet.exe',
+        'windowsterminal.exe', 'sublime_text.exe', 'zed.exe', 'terminal.app'
+    ];
+    return ideNames.includes(lowerName);
+}
+/**
+ * Get the terminal PID by walking up the process tree
+ * Matches gk-session-manager.cjs getTerminalPid()
+ */
+export function getTerminalPid() {
+    const parentPid = process.ppid;
+    try {
+        if (process.platform === 'win32') {
+            let currentPid = parentPid;
+            let lastShellPid = null;
+            for (let i = 0; i < 10; i++) {
+                const { parentPid: nextPid, processName } = getProcessInfoWin32(currentPid);
+                if (isShellProcess(processName)) {
+                    lastShellPid = currentPid;
+                }
+                if (isIDEProcess(processName) && lastShellPid) {
+                    return lastShellPid;
+                }
+                if (!nextPid || nextPid <= 4)
+                    break;
+                currentPid = nextPid;
+            }
+            return lastShellPid || parentPid;
+        }
+        else {
+            // Unix/Linux/macOS - simplified
+            return parentPid;
+        }
+    }
+    catch {
+        // Fall back to parent PID on error
+    }
+    return parentPid;
+}
+/**
+ * Ensure directory exists
+ */
+function ensureDir(dirPath) {
+    if (!existsSync(dirPath)) {
+        mkdirSync(dirPath, { recursive: true });
+    }
+}
+/**
+ * Reorder session object to put agents array at the end
+ */
+function reorderSessionFields(session) {
+    const { agents, ...rest } = session;
+    return {
+        ...rest,
+        agents: agents || []
+    };
+}
+/**
+ * Save session to file (atomic write)
+ * Matches gk-session-manager.cjs saveSession()
+ */
+export function saveSession(projectDir, gkSessionId, data) {
+    if (!projectDir || !gkSessionId)
+        return false;
+    const projectDataDir = getProjectDataDir(projectDir);
+    ensureDir(projectDataDir);
+    const sessionPath = getSessionPath(projectDir, gkSessionId);
+    const tempPath = `${sessionPath}.tmp`;
+    try {
+        const orderedData = reorderSessionFields(data);
+        writeFileSync(tempPath, JSON.stringify(orderedData, null, 2), 'utf8');
+        // Atomic rename
+        renameSync(tempPath, sessionPath);
+        return true;
+    }
+    catch {
+        try {
+            unlinkSync(tempPath);
+        }
+        catch { /* ignore */ }
+        return false;
+    }
+}
+/**
+ * Update .gemini/.env with session and project info
+ * Matches gk-session-manager.cjs updateEnv()
+ */
+export function updateEnv(envData) {
+    try {
+        const envPath = getLocalEnvPath();
+        const content = [
+            '# Auto-generated by gemkit-cli',
+            `# Updated at: ${new Date().toISOString()}`,
+            '',
+            '# GEMKIT IDs',
+            `ACTIVE_GK_SESSION_ID=${envData.gkSessionId || ''}`,
+            `GK_PROJECT_HASH=${envData.gkProjectHash || ''}`,
+            `PROJECT_DIR=${envData.projectDir || ''}`,
+            '',
+            '# GEMINI IDs (mapped)',
+            `ACTIVE_GEMINI_SESSION_ID=${envData.geminiSessionId || ''}`,
+            `GEMINI_PROJECT_HASH=${envData.geminiProjectHash || ''}`,
+            '',
+            '# PLAN INFO',
+            `ACTIVE_PLAN=${envData.activePlan || ''}`,
+            `SUGGESTED_PLAN=${envData.suggestedPlan || ''}`,
+            `PLAN_DATE_FORMAT=${envData.planDateFormat || ''}`,
+            ''
+        ].join('\n');
+        // Ensure .gemini directory exists
+        const geminiDir = join(process.cwd(), '.gemini');
+        ensureDir(geminiDir);
+        writeFileSync(envPath, content, 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get project data (internal helper)
+ */
+function getProjectInternal(projectDir, gkProjectHash) {
+    if (!projectDir || !gkProjectHash)
+        return null;
+    const projectPath = getProjectPath(projectDir, gkProjectHash);
+    if (!existsSync(projectPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(projectPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save project data
+ */
+export function saveProject(projectDir, gkProjectHash, data) {
+    if (!projectDir || !gkProjectHash)
+        return false;
+    const projectDataDir = getProjectDataDir(projectDir);
+    ensureDir(projectDataDir);
+    const projectPath = getProjectPath(projectDir, gkProjectHash);
+    try {
+        writeFileSync(projectPath, JSON.stringify(data, null, 2), 'utf8');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create or get project
+ */
+export function ensureProject(projectDir, gkProjectHash, projectPath) {
+    let project = getProjectInternal(projectDir, gkProjectHash);
+    if (!project) {
+        project = {
+            gkProjectHash: gkProjectHash,
+            projectDir: projectDir,
+            projectPath: projectPath || process.cwd(),
+            geminiProjectHash: null,
+            initialized: true,
+            initTimestamp: new Date().toISOString(),
+            lastActiveTimestamp: new Date().toISOString(),
+            activeGkSessionId: null,
+            sessions: []
+        };
+        saveProject(projectDir, gkProjectHash, project);
+    }
+    return project;
+}
+/**
+ * Add session summary to project
+ */
+export function addSessionToProject(projectDir, gkProjectHash, sessionSummary) {
+    const project = ensureProject(projectDir, gkProjectHash);
+    project.activeGkSessionId = sessionSummary.gkSessionId;
+    project.lastActiveTimestamp = new Date().toISOString();
+    const existingIndex = project.sessions.findIndex(s => s.gkSessionId === sessionSummary.gkSessionId);
+    if (existingIndex >= 0) {
+        const existing = project.sessions[existingIndex];
+        project.sessions[existingIndex] = {
+            gkSessionId: sessionSummary.gkSessionId,
+            pid: sessionSummary.pid ?? existing.pid,
+            sessionType: sessionSummary.sessionType || existing.sessionType,
+            appName: sessionSummary.appName || existing.appName,
+            prompt: sessionSummary.prompt ?? existing.prompt ?? null,
+            activePlan: sessionSummary.activePlan ?? existing.activePlan ?? null,
+            startTime: sessionSummary.startTime || existing.startTime,
+            endTime: sessionSummary.endTime ?? existing.endTime ?? null
+        };
+    }
+    else {
+        project.sessions.push({
+            gkSessionId: sessionSummary.gkSessionId,
+            pid: sessionSummary.pid ?? null,
+            sessionType: sessionSummary.sessionType || 'gemini',
+            appName: sessionSummary.appName || 'gemini-main',
+            prompt: sessionSummary.prompt ?? null,
+            activePlan: sessionSummary.activePlan ?? null,
+            startTime: sessionSummary.startTime || new Date().toISOString(),
+            endTime: sessionSummary.endTime ?? null
+        });
+    }
+    // Sort sessions by startTime descending
+    project.sessions.sort((a, b) => {
+        const timeA = new Date(a.startTime || 0).getTime();
+        const timeB = new Date(b.startTime || 0).getTime();
+        return timeB - timeA;
+    });
+    return saveProject(projectDir, gkProjectHash, project);
+}
+/**
+ * Add agent to session
+ * Matches gk-session-manager.cjs addAgent()
+ */
+export function addAgent(projectDir, gkSessionId, agentData) {
+    const session = getSession(projectDir, gkSessionId);
+    if (!session)
+        return false;
+    const agentGkSessionId = agentData.gkSessionId || gkSessionId;
+    session.agents = session.agents || [];
+    const existingIndex = session.agents.findIndex(a => a.gkSessionId === agentGkSessionId);
+    if (existingIndex >= 0) {
+        const existing = session.agents[existingIndex];
+        session.agents[existingIndex] = {
+            ...existing,
+            model: existing.model || agentData.model || null,
+            prompt: existing.prompt || agentData.prompt || null
+        };
+    }
+    else {
+        const agent = {
+            gkSessionId: agentGkSessionId,
+            pid: agentData.pid || null,
+            geminiSessionId: agentData.geminiSessionId || null,
+            geminiProjectHash: agentData.geminiProjectHash || null,
+            parentGkSessionId: agentData.parentGkSessionId || null,
+            agentType: agentData.parentGkSessionId ? 'Sub Agent' : 'Main Agent',
+            agentRole: agentData.agentRole || 'main',
+            prompt: agentData.prompt || null,
+            model: agentData.model || null,
+            tokenUsage: agentData.tokenUsage || null,
+            retryCount: agentData.retryCount || 0,
+            resumeCount: agentData.resumeCount || 0,
+            generation: agentData.generation || 0,
+            injected: agentData.injected || null,
+            startTime: new Date().toISOString(),
+            endTime: null,
+            status: 'active',
+            exitCode: null,
+            error: null
+        };
+        session.agents.push(agent);
+    }
+    return saveSession(projectDir, gkSessionId, session);
+}
+/**
+ * Initialize a non-Gemini session
+ * Matches gk-session-manager.cjs initializeNonGeminiSession()
+ */
+export function initializeNonGeminiSession(appName, options = {}) {
+    const cwd = options.cwd || process.cwd();
+    const projectDir = sanitizeProjectPath(cwd);
+    const gkProjectHash = generateProjectHash(cwd);
+    // Use terminal PID for non-Gemini sessions
+    const pid = getTerminalPid();
+    const gkSessionId = generateGkSessionId(appName, pid);
+    const session = {
+        // GemKit identification
+        gkSessionId: gkSessionId,
+        gkProjectHash: gkProjectHash,
+        projectDir: projectDir,
+        // No Gemini mapping for non-Gemini sessions
+        geminiSessionId: null,
+        geminiParentId: null,
+        geminiProjectHash: null,
+        // Session metadata
+        initialized: true,
+        initTimestamp: new Date().toISOString(),
+        sessionType: 'non-gemini',
+        appName: appName,
+        pid: pid,
+        // Plan management
+        activePlan: options.activePlan || null,
+        suggestedPlan: options.suggestedPlan || null,
+        // Agents array
+        agents: []
+    };
+    // Save session
+    ensureDir(getProjectDataDir(projectDir));
+    saveSession(projectDir, gkSessionId, session);
+    // Update project
+    ensureProject(projectDir, gkProjectHash, cwd);
+    addSessionToProject(projectDir, gkProjectHash, {
+        gkSessionId: gkSessionId,
+        pid: pid,
+        sessionType: 'non-gemini',
+        appName: appName,
+        startTime: session.initTimestamp,
+        activePlan: session.activePlan
+    });
+    // Update env - CLEAR Gemini session ID for non-Gemini apps
+    const existingEnv = readEnv();
+    // Only preserve geminiProjectHash if we're in the SAME project
+    const isSameProject = existingEnv.PROJECT_DIR === projectDir;
+    const preservedGeminiProjectHash = isSameProject ? (existingEnv.GEMINI_PROJECT_HASH || '') : '';
+    updateEnv({
+        gkSessionId: gkSessionId,
+        gkProjectHash: gkProjectHash,
+        projectDir: projectDir,
+        geminiSessionId: '', // Clear - no Gemini session for non-Gemini apps
+        geminiProjectHash: preservedGeminiProjectHash,
+        activePlan: session.activePlan || '',
+        suggestedPlan: session.suggestedPlan || '',
+        planDateFormat: ''
+    });
+    return {
+        session,
+        gkSessionId,
+        pid,
+        projectDir,
+        gkProjectHash
+    };
+}
+/**
+ * Set active plan in session and .env
+ * Matches gk-session-manager.cjs setActivePlan()
+ */
+export function setActivePlan(projectDir, gkSessionId, planPath) {
+    const session = getSession(projectDir, gkSessionId);
+    if (!session)
+        return false;
+    // Update session
+    session.activePlan = planPath;
+    session.suggestedPlan = null;
+    if (!saveSession(projectDir, gkSessionId, session)) {
+        return false;
+    }
+    // Update env - preserve existing values
+    const env = readEnv();
+    return updateEnv({
+        gkSessionId: gkSessionId,
+        gkProjectHash: session.gkProjectHash || env.GK_PROJECT_HASH,
+        projectDir: projectDir,
+        geminiSessionId: session.geminiSessionId || env.ACTIVE_GEMINI_SESSION_ID,
+        geminiProjectHash: session.geminiProjectHash || env.GEMINI_PROJECT_HASH,
+        activePlan: planPath,
+        suggestedPlan: '',
+        planDateFormat: session.planDateFormat || env.PLAN_DATE_FORMAT
+    });
+}
+/**
+ * Parse gkSessionId to extract components
+ * Matches gk-session-manager.cjs parseGkSessionId()
+ */
+export function parseGkSessionId(gkSessionId) {
+    if (!gkSessionId)
+        return null;
+    // Format: {appName}-{PID}-{ts36}-{rand4}
+    const match = gkSessionId.match(/^(.+)-(\d+)-([a-z0-9]+)-([a-z0-9]{4})$/);
+    if (!match)
+        return null;
+    return {
+        appName: match[1],
+        pid: parseInt(match[2], 10),
+        timestamp: match[3],
+        random: match[4]
+    };
+}

package/dist/domains/tokens/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Tokens domain exports
+ */
+export * from './pricing.js';
+export * from './scanner.js';

package/dist/domains/tokens/index.js

@@ -0,0 +1,5 @@
+/**
+ * Tokens domain exports
+ */
+export * from './pricing.js';
+export * from './scanner.js';

package/dist/domains/tokens/pricing.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Token pricing data - Updated Jan 2026
+ * Source: https://ai.google.dev/gemini-api/docs/pricing
+ */
+import type { TokenUsage } from '../../types/index.js';
+export type { TokenUsage };
+export interface ModelPricing {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts: number;
+}
+export declare const MODEL_PRICING: Record<string, ModelPricing>;
+/**
+ * Get pricing for a model, with fallback to default
+ */
+export declare function getModelPricing(modelName: string): ModelPricing;
+export interface CostBreakdown {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts: number;
+    total: number;
+    model: string;
+    pricing: ModelPricing;
+}
+/**
+ * Calculate cost for token usage
+ */
+export declare function calculateCost(usage: TokenUsage, model?: string): CostBreakdown;
+/**
+ * Format cost as currency string
+ */
+export declare function formatCost(amount: number): string;
+/**
+ * Format token count with K/M suffix
+ */
+export declare function formatTokens(n: number): string;

package/dist/domains/tokens/pricing.js

@@ -0,0 +1,129 @@
+/**
+ * Token pricing data - Updated Jan 2026
+ * Source: https://ai.google.dev/gemini-api/docs/pricing
+ */
+export const MODEL_PRICING = {
+    'gemini-3-pro-preview': {
+        input: 2.00,
+        output: 12.00,
+        cached: 0.20,
+        thoughts: 12.00,
+    },
+    'gemini-3-flash-preview': {
+        input: 0.50,
+        output: 3.00,
+        cached: 0.05,
+        thoughts: 3.00,
+    },
+    'gemini-2.5-pro': {
+        input: 1.25,
+        output: 10.00,
+        cached: 0.125,
+        thoughts: 10.00,
+    },
+    'gemini-2.5-pro-preview': {
+        input: 1.25,
+        output: 10.00,
+        cached: 0.125,
+        thoughts: 10.00,
+    },
+    'gemini-2.5-flash': {
+        input: 0.30,
+        output: 2.50,
+        cached: 0.03,
+        thoughts: 2.50,
+    },
+    'gemini-2.5-flash-lite': {
+        input: 0.10,
+        output: 0.40,
+        cached: 0.01,
+        thoughts: 0.40,
+    },
+    'gemini-2.0-flash': {
+        input: 0.10,
+        output: 0.40,
+        cached: 0.01,
+        thoughts: 0.40,
+    },
+    'gemini-2.0-flash-exp': {
+        input: 0.10,
+        output: 0.40,
+        cached: 0.01,
+        thoughts: 0.40,
+    },
+    // Default fallback
+    'default': {
+        input: 0.50,
+        output: 3.00,
+        cached: 0.05,
+        thoughts: 3.00,
+    }
+};
+/**
+ * Get pricing for a model, with fallback to default
+ */
+export function getModelPricing(modelName) {
+    // Try exact match first
+    if (MODEL_PRICING[modelName]) {
+        return MODEL_PRICING[modelName];
+    }
+    // Try partial match
+    for (const key of Object.keys(MODEL_PRICING)) {
+        if (key.includes(modelName) || modelName.includes(key)) {
+            return MODEL_PRICING[key];
+        }
+    }
+    return MODEL_PRICING['default'];
+}
+/**
+ * Calculate cost for token usage
+ */
+export function calculateCost(usage, model = 'default') {
+    const pricing = getModelPricing(model);
+    // Input tokens: subtract cached from input (cached are billed at lower rate)
+    let actualInput = usage.input - usage.cached;
+    if (actualInput < 0)
+        actualInput = 0;
+    const inputCost = (actualInput / 1_000_000) * pricing.input;
+    const outputCost = (usage.output / 1_000_000) * pricing.output;
+    const cachedCost = (usage.cached / 1_000_000) * pricing.cached;
+    const thoughtsCost = (usage.thoughts / 1_000_000) * pricing.thoughts;
+    return {
+        input: inputCost,
+        output: outputCost,
+        cached: cachedCost,
+        thoughts: thoughtsCost,
+        total: inputCost + outputCost + cachedCost + thoughtsCost,
+        model,
+        pricing
+    };
+}
+/**
+ * Format cost as currency string
+ */
+export function formatCost(amount) {
+    if (amount >= 1.0) {
+        return `$${amount.toFixed(2)}`;
+    }
+    else if (amount >= 0.01) {
+        return `$${amount.toFixed(3)}`;
+    }
+    else if (amount >= 0.001) {
+        return `$${amount.toFixed(4)}`;
+    }
+    else {
+        return `$${amount.toFixed(6)}`;
+    }
+}
+/**
+ * Format token count with K/M suffix
+ */
+export function formatTokens(n) {
+    if (n >= 1_000_000) {
+        return `${(n / 1_000_000).toFixed(1)}M`;
+    }
+    else if (n >= 1_000) {
+        return `${(n / 1_000).toFixed(1)}K`;
+    }
+    return String(n);
+}

package/dist/domains/tokens/scanner.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Token scanner - Reads Gemini session files for token usage
+ */
+import type { TokenUsage } from './pricing.js';
+export interface SessionAnalysis {
+    sessionId: string;
+    startTime: string | null;
+    lastUpdated: string | null;
+    duration: {
+        seconds: number;
+        formatted: string;
+    } | null;
+    model: string;
+    modelsUsed: string[];
+    messageCount: number;
+    tokens: TokenUsage;
+    averages: {
+        outputPerMessage: number;
+        thoughtsPerMessage: number;
+        toolPerMessage: number;
+    };
+}
+/**
+ * Get token usage for current session only (MVP limitation)
+ */
+export declare function getCurrentSessionTokens(): Promise<SessionAnalysis | null>;
+/**
+ * Get full session analysis from latest Gemini session file
+ */
+export declare function getLatestSessionAnalysis(projectHash: string): SessionAnalysis | null;
+/**
+ * Analyze a session file and extract all stats
+ */
+export declare function analyzeSessionFile(filePath: string): SessionAnalysis | null;
+/**
+ * Get token usage by session ID
+ */
+export declare function getAgentTokenUsage(sessionId: string, projectHash: string): TokenUsage | null;
+/**
+ * Legacy format function for backward compatibility
+ */
+export declare function formatTokenUsage(usage: TokenUsage): string;