gemkit-cli 0.2.3 → 0.3.1

package/dist/domains/agent-office/renderer/web/server.d.ts

@@ -0,0 +1,42 @@
+import { OfficeEventEmitter } from '../../event-emitter.js';
+export interface WebServerOptions {
+    port: number;
+    host?: string;
+    autoOpen?: boolean;
+    emitter: OfficeEventEmitter;
+}
+export declare class OfficeWebServer {
+    private server;
+    private wss;
+    private options;
+    private clients;
+    constructor(options: WebServerOptions);
+    /**
+     * Start the server
+     */
+    start(): Promise<number>;
+    /**
+     * Stop the server
+     */
+    stop(): void;
+    /**
+     * Handle HTTP requests
+     */
+    private handleRequest;
+    /**
+     * Setup WebSocket handlers
+     */
+    private setupWebSocket;
+    /**
+     * Broadcast state to all clients
+     */
+    private broadcastState;
+    /**
+     * Broadcast event to all clients
+     */
+    private broadcastEvent;
+    /**
+     * Serialize state for JSON (convert Map to object)
+     */
+    private serializeState;
+}

package/dist/domains/agent-office/renderer/web/server.js

@@ -0,0 +1,228 @@
+import { createServer } from 'http';
+import { WebSocketServer, WebSocket } from 'ws';
+import { exec } from 'child_process';
+import { existsSync } from 'fs';
+import { resolve } from 'path';
+import { getIndexHtml } from './assets.js';
+export class OfficeWebServer {
+    server = null;
+    wss = null;
+    options;
+    clients = new Set();
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Start the server
+     */
+    async start() {
+        return new Promise((resolve, reject) => {
+            let port = this.options.port;
+            let attempts = 0;
+            const maxAttempts = 10;
+            const tryStart = () => {
+                this.server = createServer((req, res) => this.handleRequest(req, res));
+                this.server.on('error', (err) => {
+                    if (err.code === 'EADDRINUSE' && attempts < maxAttempts) {
+                        attempts++;
+                        port++;
+                        tryStart();
+                    }
+                    else {
+                        reject(err);
+                    }
+                });
+                this.server.listen(port, this.options.host || 'localhost', () => {
+                    // Setup WebSocket server
+                    this.wss = new WebSocketServer({ server: this.server });
+                    this.setupWebSocket();
+                    // Subscribe to state changes
+                    this.options.emitter.onStateChange((state) => {
+                        this.broadcastState(state);
+                    });
+                    this.options.emitter.onEvent((event) => {
+                        this.broadcastEvent(event);
+                    });
+                    resolve(port);
+                });
+            };
+            tryStart();
+        });
+    }
+    /**
+     * Stop the server
+     */
+    stop() {
+        if (this.wss) {
+            for (const client of this.clients) {
+                client.close();
+            }
+            this.wss.close();
+            this.wss = null;
+        }
+        if (this.server) {
+            this.server.close();
+            this.server = null;
+        }
+        this.clients.clear();
+    }
+    /**
+     * Handle HTTP requests
+     */
+    handleRequest(req, res) {
+        const url = req.url || '/';
+        // API endpoints
+        if (url === '/api/state') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(this.serializeState(this.options.emitter.getState())));
+            return;
+        }
+        if (url === '/api/history') {
+            res.writeHead(200, { 'Content-Type': 'application/json' });
+            res.end(JSON.stringify(this.options.emitter.getHistory()));
+            return;
+        }
+        // Open document API
+        if (url.startsWith('/api/open-doc')) {
+            const urlObj = new URL(url, `http://${req.headers.host}`);
+            const docPath = urlObj.searchParams.get('path');
+            if (!docPath) {
+                res.writeHead(400, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: 'No path provided' }));
+                return;
+            }
+            // Path could be absolute or relative - try both
+            let fullPath = docPath;
+            if (!existsSync(fullPath)) {
+                fullPath = resolve(process.cwd(), docPath);
+            }
+            if (!existsSync(fullPath)) {
+                res.writeHead(404, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ success: false, error: `File not found: ${docPath}` }));
+                return;
+            }
+            // Detect IDE from multiple sources
+            // Priority: EDITOR env var > session appName (if valid) > code (fallback)
+            const editor = process.env.EDITOR || process.env.VISUAL;
+            const state = this.options.emitter.getState();
+            const sessionAppName = state.appName?.toLowerCase() || '';
+            // Valid IDE commands whitelist
+            const validIdes = ['code', 'cursor', 'windsurf', 'zed', 'vim', 'nvim', 'nano', 'subl', 'atom', 'idea', 'webstorm', 'notepad++', 'antigravity'];
+            const isValidIde = validIdes.some(ide => sessionAppName.includes(ide));
+            let command;
+            if (editor) {
+                // User explicitly set EDITOR env var - use that
+                command = `"${editor}" "${fullPath}"`;
+                console.log(`[Agent Office] Using IDE from EDITOR env: ${editor}`);
+            }
+            else if (sessionAppName && isValidIde) {
+                // Use appName from session only if it's a valid IDE
+                command = `${sessionAppName} "${fullPath}"`;
+                console.log(`[Agent Office] Using IDE from session: ${sessionAppName}`);
+            }
+            else {
+                // Fallback to VS Code
+                command = `code "${fullPath}"`;
+                console.log('[Agent Office] No IDE detected, defaulting to VS Code');
+            }
+            exec(command, (error) => {
+                if (error) {
+                    res.writeHead(500, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: false, error: error.message }));
+                }
+                else {
+                    res.writeHead(200, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ success: true }));
+                }
+            });
+            return;
+        }
+        // Serve embedded index.html for root path
+        const urlPath = url.split('?')[0].split('#')[0];
+        if (urlPath === '/' || urlPath === '/index.html') {
+            res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+            res.end(getIndexHtml());
+            return;
+        }
+        // All other paths return 404 (CSS/JS are inlined in HTML)
+        res.writeHead(404);
+        res.end('Not Found');
+    }
+    /**
+     * Setup WebSocket handlers
+     */
+    setupWebSocket() {
+        if (!this.wss)
+            return;
+        this.wss.on('connection', (ws) => {
+            this.clients.add(ws);
+            // Send current state immediately
+            const state = this.options.emitter.getState();
+            try {
+                ws.send(JSON.stringify({ type: 'state', data: this.serializeState(state) }));
+            }
+            catch (e) {
+                // Ignore send errors on initial connect
+            }
+            ws.on('message', (data) => {
+                try {
+                    const msg = JSON.parse(data.toString());
+                    if (msg.type === 'ping') {
+                        ws.send(JSON.stringify({ type: 'pong' }));
+                    }
+                    if (msg.type === 'replay') {
+                        const events = this.options.emitter.replay(msg.fromTimestamp);
+                        ws.send(JSON.stringify({ type: 'replay', data: events }));
+                    }
+                }
+                catch (e) {
+                    // Ignore invalid messages
+                }
+            });
+            ws.on('close', () => {
+                this.clients.delete(ws);
+            });
+        });
+    }
+    /**
+     * Broadcast state to all clients
+     */
+    broadcastState(state) {
+        const message = JSON.stringify({ type: 'state', data: this.serializeState(state) });
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                try {
+                    client.send(message);
+                }
+                catch (e) {
+                    // Ignore send errors
+                }
+            }
+        }
+    }
+    /**
+     * Broadcast event to all clients
+     */
+    broadcastEvent(event) {
+        const message = JSON.stringify({ type: 'event', data: event });
+        for (const client of this.clients) {
+            if (client.readyState === WebSocket.OPEN) {
+                try {
+                    client.send(message);
+                }
+                catch (e) {
+                    // Ignore send errors
+                }
+            }
+        }
+    }
+    /**
+     * Serialize state for JSON (convert Map to object)
+     */
+    serializeState(state) {
+        return {
+            ...state,
+            agents: Object.fromEntries(state.agents),
+        };
+    }
+}

package/dist/domains/agent-office/renderer/web.d.ts

@@ -0,0 +1,30 @@
+export interface WebDashboardOptions {
+    port?: number;
+    host?: string;
+    autoOpen?: boolean;
+    onReady?: (port: number) => void;
+    onError?: (error: Error) => void;
+}
+export declare class WebDashboard {
+    private server;
+    private emitter;
+    private watcher;
+    private options;
+    constructor(options?: WebDashboardOptions);
+    /**
+     * Start the web dashboard
+     */
+    start(): Promise<number>;
+    /**
+     * Stop the dashboard
+     */
+    stop(): void;
+    /**
+     * Open browser to URL
+     */
+    private openBrowser;
+}
+/**
+ * Start web dashboard (convenience function)
+ */
+export declare function startWebDashboard(options?: WebDashboardOptions): Promise<WebDashboard>;

package/dist/domains/agent-office/renderer/web.js

@@ -0,0 +1,111 @@
+import { exec } from 'child_process';
+import { join } from 'path';
+import { OfficeEventEmitter } from '../event-emitter.js';
+import { SessionFileWatcher } from '../file-watcher.js';
+import { sessionToOfficeState } from '../session-bridge.js';
+import { scanPlanDocuments } from '../documents-scanner.js';
+import { OfficeWebServer } from './web/server.js';
+import { createInitialState } from '../state-machine.js';
+import { getPlansDir } from '../../../utils/paths.js';
+export class WebDashboard {
+    server = null;
+    emitter;
+    watcher;
+    options;
+    constructor(options = {}) {
+        this.options = {
+            port: 3847,
+            host: 'localhost',
+            autoOpen: true,
+            ...options,
+        };
+        // Initialize event emitter
+        this.emitter = new OfficeEventEmitter(createInitialState());
+        // Initialize file watcher
+        this.watcher = new SessionFileWatcher({
+            onSessionChange: (session) => {
+                const state = sessionToOfficeState(session);
+                // Scan documents if plan set
+                if (state.activePlan) {
+                    try {
+                        const plansDir = getPlansDir();
+                        const planPath = join(plansDir, state.activePlan);
+                        state.documents = scanPlanDocuments(planPath);
+                    }
+                    catch (e) {
+                        // Ignore doc scan errors
+                    }
+                }
+                this.emitter.setState(state);
+            },
+            onEvent: (event) => {
+                this.emitter.emit(event);
+            },
+            onError: (error) => {
+                if (this.options.onError) {
+                    this.options.onError(error);
+                }
+            },
+        });
+    }
+    /**
+     * Start the web dashboard
+     */
+    async start() {
+        // Start file watcher
+        const watcherStarted = this.watcher.start();
+        if (!watcherStarted) {
+            throw new Error('No active session found');
+        }
+        // Create and start server
+        this.server = new OfficeWebServer({
+            port: this.options.port,
+            host: this.options.host,
+            emitter: this.emitter,
+        });
+        const actualPort = await this.server.start();
+        // Auto-open browser
+        if (this.options.autoOpen) {
+            this.openBrowser(`http://${this.options.host}:${actualPort}`);
+        }
+        if (this.options.onReady) {
+            this.options.onReady(actualPort);
+        }
+        return actualPort;
+    }
+    /**
+     * Stop the dashboard
+     */
+    stop() {
+        if (this.server) {
+            this.server.stop();
+            this.server = null;
+        }
+        this.watcher.stop();
+        this.emitter.dispose();
+    }
+    /**
+     * Open browser to URL
+     */
+    openBrowser(url) {
+        const command = process.platform === 'win32'
+            ? `start ${url}`
+            : process.platform === 'darwin'
+                ? `open ${url}`
+                : `xdg-open ${url}`;
+        exec(command, (error) => {
+            if (error) {
+                // Log to console if browser opening fails
+                console.log(`Open ${url} in your browser`);
+            }
+        });
+    }
+}
+/**
+ * Start web dashboard (convenience function)
+ */
+export async function startWebDashboard(options = {}) {
+    const dashboard = new WebDashboard(options);
+    await dashboard.start();
+    return dashboard;
+}

package/dist/domains/agent-office/session-bridge.d.ts

@@ -0,0 +1,23 @@
+import { GkSession, GkAgent } from '../session/types.js';
+import { OfficeState, OfficeAgent, OrchestratorAgent, InboxItem, CharacterType } from './types.js';
+/**
+ * Map agent role to character type
+ * Must match JS role detection: research, code/executor, plan, test, design/ui/ux
+ */
+export declare function getCharacterType(role: string): CharacterType;
+/**
+ * Check if agent is the orchestrator (Main Agent)
+ */
+export declare function isOrchestrator(agent: GkAgent, session: GkSession): boolean;
+/**
+ * Convert single GkAgent to OfficeAgent
+ */
+export declare function agentToOfficeAgent(agent: GkAgent, session: GkSession): OfficeAgent | OrchestratorAgent;
+/**
+ * Generate inbox item from completed agent
+ */
+export declare function agentToInboxItem(agent: GkAgent): InboxItem;
+/**
+ * Convert full GkSession to OfficeState
+ */
+export declare function sessionToOfficeState(session: GkSession | null): OfficeState;

package/dist/domains/agent-office/session-bridge.js

@@ -0,0 +1,171 @@
+import { createInitialState } from './state-machine.js';
+import { getIconForRole, formatDisplayName } from './icons.js';
+/**
+ * Map agent role to character type
+ * Must match JS role detection: research, code/executor, plan, test, design/ui/ux
+ */
+export function getCharacterType(role) {
+    const r = role.toLowerCase();
+    // Only main agent is orchestrator
+    if (r.includes('main'))
+        return 'orchestrator';
+    // Match roles to JS detection logic
+    if (r.includes('research') || r.includes('scout'))
+        return 'researcher';
+    if (r.includes('code') || r.includes('executor') || r.includes('debug'))
+        return 'coder';
+    if (r.includes('plan'))
+        return 'planner';
+    if (r.includes('test'))
+        return 'tester';
+    if (r.includes('design') || r.includes('ui') || r.includes('ux') || r.includes('artist'))
+        return 'designer';
+    // Legacy mappings
+    if (r.includes('doc') || r.includes('writer'))
+        return 'writer';
+    if (r.includes('manager') || r.includes('git'))
+        return 'manager';
+    // Everything else goes to other
+    return 'other';
+}
+/**
+ * Check if agent is the orchestrator (Main Agent)
+ */
+export function isOrchestrator(agent, session) {
+    return (agent.agentType === 'Main Agent' ||
+        agent.parentGkSessionId === null ||
+        agent.gkSessionId === session.gkSessionId);
+}
+/**
+ * Map GkAgent status to OfficeAgent state
+ */
+function mapStatusToState(status, hasActiveSkill) {
+    if (status === 'active') {
+        return hasActiveSkill ? 'working' : 'working';
+    }
+    if (status === 'completed')
+        return 'idle';
+    if (status === 'failed')
+        return 'idle';
+    return 'idle';
+}
+/**
+ * Calculate progress from agent timing
+ */
+function calculateProgress(agent) {
+    if (agent.status === 'completed')
+        return 100;
+    if (agent.status === 'failed')
+        return 0;
+    if (!agent.startTime)
+        return 0;
+    const start = new Date(agent.startTime).getTime();
+    const now = Date.now();
+    const elapsed = now - start;
+    // Estimate based on typical task duration (2 min default)
+    const estimatedMs = 120000;
+    return Math.min(100, Math.round((elapsed / estimatedMs) * 100));
+}
+/**
+ * Generate speech bubble based on agent state
+ */
+function generateSpeechBubble(agent) {
+    if (agent.status === 'completed')
+        return 'Task complete!';
+    if (agent.status === 'failed')
+        return 'Task failed';
+    if (agent.injected?.skills?.length) {
+        return `Working on ${agent.injected.skills[0]}...`;
+    }
+    return null;
+}
+/**
+ * Convert single GkAgent to OfficeAgent
+ */
+export function agentToOfficeAgent(agent, session) {
+    const isOrch = isOrchestrator(agent, session);
+    const hasActiveSkill = !!(agent.injected?.skills?.length && agent.status === 'active');
+    const role = agent.agentRole || 'unknown';
+    const base = {
+        id: agent.gkSessionId,
+        agentType: isOrch ? 'orchestrator' : 'sub-agent',
+        role,
+        characterType: getCharacterType(role),
+        icon: getIconForRole(role, isOrch),
+        state: mapStatusToState(agent.status, hasActiveSkill),
+        activeSkill: agent.injected?.skills?.[0] || null,
+        progress: calculateProgress(agent),
+        speechBubble: generateSpeechBubble(agent),
+        hasFireEffect: hasActiveSkill,
+        gkSessionId: agent.gkSessionId,
+        parentSessionId: agent.parentGkSessionId,
+    };
+    if (isOrch) {
+        const subAgents = session.agents.filter(a => !isOrchestrator(a, session));
+        return {
+            ...base,
+            agentType: 'orchestrator',
+            delegatedTo: subAgents.filter(a => a.status === 'active').map(a => a.gkSessionId),
+            totalSubAgents: subAgents.length,
+            completedSubAgents: subAgents.filter(a => a.status === 'completed').length,
+        };
+    }
+    return base;
+}
+/**
+ * Generate inbox item from completed agent
+ */
+export function agentToInboxItem(agent) {
+    const duration = agent.endTime && agent.startTime
+        ? new Date(agent.endTime).getTime() - new Date(agent.startTime).getTime()
+        : 0;
+    return {
+        id: `inbox-${agent.gkSessionId}`,
+        agentId: agent.gkSessionId,
+        agentRole: agent.agentRole || 'unknown',
+        agentIcon: getIconForRole(agent.agentRole || ''),
+        timestamp: agent.endTime ? new Date(agent.endTime).getTime() : Date.now(),
+        status: 'unread',
+        title: `${formatDisplayName(agent.agentRole || 'Agent')} completed`,
+        preview: agent.prompt ? agent.prompt.slice(0, 100) : 'Task completed',
+        fullContent: null,
+        tokenUsage: agent.tokenUsage
+            ? { input: agent.tokenUsage.input, output: agent.tokenUsage.output }
+            : null,
+        duration,
+        skillsUsed: agent.injected?.skills || [],
+    };
+}
+/**
+ * Convert full GkSession to OfficeState
+ */
+export function sessionToOfficeState(session) {
+    const state = createInitialState();
+    if (!session)
+        return state;
+    state.sessionId = session.gkSessionId;
+    state.projectDir = session.projectDir;
+    state.activePlan = session.activePlan;
+    state.appName = session.appName || null; // IDE name from gk session init
+    state.isActive = session.agents.some(a => a.status === 'active');
+    // Process agents
+    for (const agent of session.agents) {
+        const officeAgent = agentToOfficeAgent(agent, session);
+        if (officeAgent.agentType === 'orchestrator') {
+            state.orchestrator = officeAgent;
+        }
+        else {
+            state.agents.set(officeAgent.id, officeAgent);
+        }
+        // Add completed agents to inbox
+        if (agent.status === 'completed') {
+            const existingItem = state.inbox.find(i => i.agentId === agent.gkSessionId);
+            if (!existingItem) {
+                state.inbox.push(agentToInboxItem(agent));
+            }
+        }
+    }
+    // Sort inbox by timestamp descending
+    state.inbox.sort((a, b) => b.timestamp - a.timestamp);
+    return state;
+}

package/dist/domains/agent-office/state-machine.d.ts

@@ -0,0 +1,5 @@
+import { AgentState, OfficeState, OfficeAgent, OfficeEvent } from './types.js';
+export declare function isValidTransition(from: AgentState, to: AgentState): boolean;
+export declare function createInitialState(): OfficeState;
+export declare function transitionAgent(agent: OfficeAgent, event: OfficeEvent): OfficeAgent;
+export declare function processEvent(state: OfficeState, event: OfficeEvent): OfficeState;

package/dist/domains/agent-office/state-machine.js

@@ -0,0 +1,82 @@
+// Valid state transitions
+const VALID_TRANSITIONS = {
+    idle: ['working', 'walking', 'receiving'],
+    working: ['idle', 'delivering', 'walking'],
+    walking: ['idle', 'working', 'delivering'],
+    delivering: ['idle', 'walking'],
+    receiving: ['working', 'idle'],
+};
+export function isValidTransition(from, to) {
+    return VALID_TRANSITIONS[from]?.includes(to) ?? false;
+}
+export function createInitialState() {
+    return {
+        orchestrator: null,
+        agents: new Map(),
+        sessionId: null,
+        projectDir: null,
+        activePlan: null,
+        appName: null,
+        currentNotification: null,
+        inbox: [],
+        documents: [],
+        isActive: false,
+    };
+}
+export function transitionAgent(agent, event) {
+    // Map event type to new state
+    const stateMap = {
+        agent_idle: 'idle',
+        agent_working: 'working',
+        skill_activated: 'working',
+        handoff_start: 'walking',
+        received_work: 'receiving',
+        delivering: 'delivering',
+        task_complete: 'idle',
+    };
+    const newState = stateMap[event.type];
+    if (!newState)
+        return agent;
+    if (!isValidTransition(agent.state, newState)) {
+        return agent; // Invalid transition, no change
+    }
+    return {
+        ...agent,
+        state: newState,
+        activeSkill: event.skill ?? agent.activeSkill,
+        hasFireEffect: event.type === 'skill_activated',
+        speechBubble: event.message || null,
+    };
+}
+export function processEvent(state, event) {
+    // Update agent state
+    const agent = state.agents.get(event.agentId);
+    if (agent) {
+        state.agents.set(event.agentId, transitionAgent(agent, event));
+    }
+    else if (state.orchestrator && state.orchestrator.id === event.agentId) {
+        state.orchestrator = transitionAgent(state.orchestrator, event); // Cast as any to handle type overlap
+    }
+    // Generate notification if needed
+    const notification = generateNotification(event);
+    if (notification) {
+        state.currentNotification = notification;
+    }
+    return { ...state };
+}
+function generateNotification(event) {
+    const notificationMap = {
+        skill_activated: { type: 'skill', template: `Skill activated: ${event.skill}` },
+        handoff_start: { type: 'handoff', template: 'Agent delivering information...' },
+        handoff_complete: { type: 'handoff', template: 'Handoff complete!' },
+        task_complete: { type: 'success', template: 'Task completed! Check your inbox' },
+    };
+    const config = notificationMap[event.type];
+    if (!config)
+        return null;
+    return {
+        message: config.template,
+        type: config.type,
+        timestamp: event.timestamp,
+    };
+}