gemkit-cli 0.2.3 → 0.3.1

package/dist/domains/agent/types.js

@@ -0,0 +1,5 @@
+/**
+ * Agent type definitions for MVP
+ * Aligned with Python core.py types
+ */
+export {};

package/dist/domains/agent-office/documents-scanner.d.ts

@@ -0,0 +1,9 @@
+import { PlanDocument, DocumentType } from './types.js';
+/**
+ * Scan plan folder for documents
+ */
+export declare function scanPlanDocuments(planPath: string): PlanDocument[];
+/**
+ * Group documents by type for display
+ */
+export declare function groupDocumentsByType(documents: PlanDocument[]): Record<DocumentType, PlanDocument[]>;

package/dist/domains/agent-office/documents-scanner.js

@@ -0,0 +1,143 @@
+import { existsSync, readdirSync, statSync } from 'fs';
+import { join, basename, extname, relative } from 'path';
+import { createHash } from 'crypto';
+/**
+ * Get icon for document type/extension
+ */
+function getDocumentIcon(type, ext) {
+    const typeIcons = {
+        plan: '\uD83D\uDCCB', // clipboard
+        phase: '\uD83D\uDCD1', // bookmark tabs
+        research: '\uD83D\uDD0D', // magnifier
+        artifact: '\uD83D\uDCE6', // package
+        report: '\uD83D\uDCCA', // chart
+        other: '\uD83D\uDCC4', // document
+    };
+    if (type === 'artifact') {
+        const extIcons = {
+            sql: '\uD83D\uDDC4\uFE0F', // file cabinet
+            json: '\uD83D\uDCE6', // package
+            png: '\uD83D\uDDBC\uFE0F', // frame
+            jpg: '\uD83D\uDDBC\uFE0F', // frame
+            ts: '\uD83D\uDCBB', // laptop
+            js: '\uD83D\uDCBB', // laptop
+        };
+        return extIcons[ext] || typeIcons.artifact;
+    }
+    return typeIcons[type];
+}
+/**
+ * Extract phase number from filename
+ */
+function extractPhaseNumber(name) {
+    const match = name.match(/^phase-(\d+)/);
+    return match ? parseInt(match[1], 10) : null;
+}
+/**
+ * Format document name for display
+ */
+function formatDocumentName(name, type) {
+    if (type === 'phase') {
+        const num = extractPhaseNumber(name);
+        const rest = name.replace(/^phase-\d+-?/, '').replace(/-/g, ' ');
+        return num !== null ? `Phase ${num}: ${rest}` : name;
+    }
+    return name.replace(/-/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+}
+/**
+ * Create document object from file path
+ */
+function createDocument(filePath, type, planPath) {
+    const stat = statSync(filePath);
+    const name = basename(filePath, extname(filePath));
+    const ext = extname(filePath).slice(1);
+    return {
+        id: createHash('md5').update(filePath).digest('hex').slice(0, 8),
+        name,
+        displayName: formatDocumentName(name, type),
+        type,
+        icon: getDocumentIcon(type, ext),
+        path: filePath,
+        relativePath: relative(planPath, filePath),
+        modifiedAt: stat.mtimeMs,
+        createdAt: stat.birthtimeMs,
+        size: stat.size,
+        extension: ext,
+        phaseNumber: extractPhaseNumber(name),
+    };
+}
+/**
+ * Scan plan folder for documents
+ */
+export function scanPlanDocuments(planPath) {
+    if (!existsSync(planPath))
+        return [];
+    const documents = [];
+    // 1. Scan plan.md (main plan)
+    const planFile = join(planPath, 'plan.md');
+    if (existsSync(planFile)) {
+        documents.push(createDocument(planFile, 'plan', planPath));
+    }
+    // 2. Scan phase-*.md or phase-*/ directories
+    const rootFiles = readdirSync(planPath);
+    for (const file of rootFiles) {
+        const fullPath = join(planPath, file);
+        const stat = statSync(fullPath);
+        if (file.startsWith('phase-')) {
+            if (stat.isDirectory()) {
+                // Check for phase.md inside directory
+                const phaseFile = join(fullPath, 'phase.md');
+                if (existsSync(phaseFile)) {
+                    documents.push(createDocument(phaseFile, 'phase', planPath));
+                }
+            }
+            else if (file.endsWith('.md')) {
+                documents.push(createDocument(fullPath, 'phase', planPath));
+            }
+        }
+    }
+    // 3. Scan research/ folder
+    const researchDir = join(planPath, 'research');
+    if (existsSync(researchDir)) {
+        const researchFiles = readdirSync(researchDir).filter(f => f.endsWith('.md'));
+        for (const file of researchFiles) {
+            documents.push(createDocument(join(researchDir, file), 'research', planPath));
+        }
+    }
+    // 4. Scan artifacts/ folder
+    const artifactsDir = join(planPath, 'artifacts');
+    if (existsSync(artifactsDir)) {
+        const artifactFiles = readdirSync(artifactsDir);
+        for (const file of artifactFiles) {
+            const fullPath = join(artifactsDir, file);
+            if (statSync(fullPath).isFile()) {
+                documents.push(createDocument(fullPath, 'artifact', planPath));
+            }
+        }
+    }
+    // 5. Scan reports/ folder
+    const reportsDir = join(planPath, 'reports');
+    if (existsSync(reportsDir)) {
+        const reportFiles = readdirSync(reportsDir).filter(f => f.endsWith('.md'));
+        for (const file of reportFiles) {
+            documents.push(createDocument(join(reportsDir, file), 'report', planPath));
+        }
+    }
+    // Sort by modification time (newest first)
+    documents.sort((a, b) => b.modifiedAt - a.modifiedAt);
+    return documents;
+}
+/**
+ * Group documents by type for display
+ */
+export function groupDocumentsByType(documents) {
+    return {
+        plan: documents.filter(d => d.type === 'plan'),
+        phase: documents.filter(d => d.type === 'phase')
+            .sort((a, b) => (b.phaseNumber || 0) - (a.phaseNumber || 0)),
+        research: documents.filter(d => d.type === 'research'),
+        artifact: documents.filter(d => d.type === 'artifact'),
+        report: documents.filter(d => d.type === 'report'),
+        other: documents.filter(d => d.type === 'other'),
+    };
+}

package/dist/domains/agent-office/event-emitter.d.ts

@@ -0,0 +1,43 @@
+import { OfficeState, OfficeEvent } from './types.js';
+type StateListener = (state: OfficeState) => void;
+type EventListener = (event: OfficeEvent) => void;
+export declare class OfficeEventEmitter {
+    private state;
+    private stateListeners;
+    private eventListeners;
+    private eventHistory;
+    constructor(initialState: OfficeState);
+    /**
+     * Subscribe to state changes
+     */
+    onStateChange(listener: StateListener): () => void;
+    /**
+     * Subscribe to individual events
+     */
+    onEvent(listener: EventListener): () => void;
+    /**
+     * Emit an event and update state
+     */
+    emit(event: OfficeEvent): void;
+    /**
+     * Update state and notify listeners
+     */
+    setState(newState: OfficeState): void;
+    /**
+     * Get current state snapshot
+     */
+    getState(): OfficeState;
+    /**
+     * Get event history
+     */
+    getHistory(): OfficeEvent[];
+    /**
+     * Replay events from a timestamp
+     */
+    replay(fromTimestamp: number): OfficeEvent[];
+    /**
+     * Clear all listeners (for cleanup)
+     */
+    dispose(): void;
+}
+export {};

package/dist/domains/agent-office/event-emitter.js

@@ -0,0 +1,86 @@
+const MAX_HISTORY_SIZE = 1000;
+export class OfficeEventEmitter {
+    state;
+    stateListeners = new Set();
+    eventListeners = new Set();
+    eventHistory = [];
+    constructor(initialState) {
+        this.state = initialState;
+    }
+    /**
+     * Subscribe to state changes
+     */
+    onStateChange(listener) {
+        this.stateListeners.add(listener);
+        // Immediately notify with current state
+        listener(this.state);
+        return () => this.stateListeners.delete(listener);
+    }
+    /**
+     * Subscribe to individual events
+     */
+    onEvent(listener) {
+        this.eventListeners.add(listener);
+        return () => this.eventListeners.delete(listener);
+    }
+    /**
+     * Emit an event and update state
+     */
+    emit(event) {
+        // Store in history
+        this.eventHistory.push(event);
+        if (this.eventHistory.length > MAX_HISTORY_SIZE) {
+            this.eventHistory.shift();
+        }
+        // Notify event listeners
+        for (const listener of this.eventListeners) {
+            try {
+                listener(event);
+            }
+            catch (e) {
+                console.error('Event listener error:', e);
+            }
+        }
+    }
+    /**
+     * Update state and notify listeners
+     */
+    setState(newState) {
+        this.state = newState;
+        // Notify state listeners
+        for (const listener of this.stateListeners) {
+            try {
+                listener(this.state);
+            }
+            catch (e) {
+                console.error('State listener error:', e);
+            }
+        }
+    }
+    /**
+     * Get current state snapshot
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get event history
+     */
+    getHistory() {
+        return [...this.eventHistory];
+    }
+    /**
+     * Replay events from a timestamp
+     */
+    replay(fromTimestamp) {
+        return this.eventHistory.filter(e => e.timestamp >= fromTimestamp);
+    }
+    /**
+     * Clear all listeners (for cleanup)
+     */
+    dispose() {
+        this.stateListeners.clear();
+        this.eventListeners.clear();
+        this.eventHistory = [];
+    }
+}

package/dist/domains/agent-office/file-watcher.d.ts

@@ -0,0 +1,40 @@
+import { GkSession } from '../session/types.js';
+import { OfficeEvent } from './types.js';
+export interface FileWatcherOptions {
+    onSessionChange: (session: GkSession) => void;
+    onEvent: (event: OfficeEvent) => void;
+    onError: (error: Error) => void;
+}
+export declare class SessionFileWatcher {
+    private pollInterval;
+    private previousSession;
+    private previousMtime;
+    private options;
+    private sessionPath;
+    constructor(options: FileWatcherOptions);
+    /**
+     * Start watching the active session file
+     * Uses polling for reliable cross-platform support (fs.watch is unreliable on Windows)
+     */
+    start(): boolean;
+    /**
+     * Stop watching
+     */
+    stop(): void;
+    /**
+     * Check if file has changed by comparing modification time
+     */
+    private checkForChanges;
+    /**
+     * Load session and emit events for changes
+     */
+    private loadSession;
+    /**
+     * Diff two sessions and generate events
+     */
+    private diffSessions;
+    /**
+     * Create event from agent
+     */
+    private createEvent;
+}

package/dist/domains/agent-office/file-watcher.js

@@ -0,0 +1,173 @@
+import { existsSync, readFileSync, statSync } from 'fs';
+import { getSessionPath } from '../../utils/paths.js';
+import { readEnv } from '../session/env.js';
+import { getCharacterType } from './session-bridge.js';
+// Polling interval - 200ms for fast detection
+const POLL_INTERVAL_MS = 200;
+export class SessionFileWatcher {
+    pollInterval = null;
+    previousSession = null;
+    previousMtime = 0;
+    options;
+    sessionPath = null;
+    constructor(options) {
+        this.options = options;
+    }
+    /**
+     * Start watching the active session file
+     * Uses polling for reliable cross-platform support (fs.watch is unreliable on Windows)
+     */
+    start() {
+        const env = readEnv();
+        const projectDir = env.PROJECT_DIR;
+        const gkSessionId = env.ACTIVE_GK_SESSION_ID;
+        if (!projectDir || !gkSessionId) {
+            this.options.onError(new Error('No active session found'));
+            return false;
+        }
+        this.sessionPath = getSessionPath(projectDir, gkSessionId);
+        if (!existsSync(this.sessionPath)) {
+            this.options.onError(new Error(`Session file not found: ${this.sessionPath}`));
+            return false;
+        }
+        // Load initial session and store mtime
+        try {
+            const stat = statSync(this.sessionPath);
+            this.previousMtime = stat.mtimeMs;
+        }
+        catch (e) {
+            // Ignore stat errors on initial load
+        }
+        this.loadSession();
+        // Start polling for file changes (more reliable than fs.watch on Windows)
+        this.pollInterval = setInterval(() => {
+            this.checkForChanges();
+        }, POLL_INTERVAL_MS);
+        return true;
+    }
+    /**
+     * Stop watching
+     */
+    stop() {
+        if (this.pollInterval) {
+            clearInterval(this.pollInterval);
+            this.pollInterval = null;
+        }
+    }
+    /**
+     * Check if file has changed by comparing modification time
+     */
+    checkForChanges() {
+        if (!this.sessionPath)
+            return;
+        try {
+            const stat = statSync(this.sessionPath);
+            const currentMtime = stat.mtimeMs;
+            // Only reload if file was modified
+            if (currentMtime > this.previousMtime) {
+                this.previousMtime = currentMtime;
+                this.loadSession();
+            }
+        }
+        catch (e) {
+            // File might be temporarily unavailable during write
+        }
+    }
+    /**
+     * Load session and emit events for changes
+     */
+    loadSession() {
+        if (!this.sessionPath)
+            return;
+        try {
+            const content = readFileSync(this.sessionPath, 'utf-8');
+            const session = JSON.parse(content);
+            // Generate events from diff BEFORE updating state
+            const events = this.previousSession
+                ? this.diffSessions(this.previousSession, session)
+                : [];
+            // Update state FIRST so events can reference the new state
+            this.previousSession = session;
+            this.options.onSessionChange(session);
+            // Then emit events (now state.agents will have the agent)
+            for (const event of events) {
+                this.options.onEvent(event);
+            }
+        }
+        catch (e) {
+            this.options.onError(e);
+        }
+    }
+    /**
+     * Diff two sessions and generate events
+     */
+    diffSessions(prev, curr) {
+        const events = [];
+        const timestamp = Date.now();
+        // Map previous agents by ID
+        const prevAgents = new Map(prev.agents.map(a => [a.gkSessionId, a]));
+        for (const agent of curr.agents) {
+            const prevAgent = prevAgents.get(agent.gkSessionId);
+            if (!prevAgent) {
+                // New agent added
+                events.push(this.createEvent('received_work', agent, timestamp));
+                if (agent.injected?.skills?.length) {
+                    events.push(this.createEvent('skill_activated', agent, timestamp, agent.injected.skills[0]));
+                }
+            }
+            else {
+                // Check for status changes
+                if (prevAgent.status === 'active' && agent.status === 'completed') {
+                    events.push(this.createEvent('task_complete', agent, timestamp));
+                    events.push(this.createEvent('delivering', agent, timestamp));
+                }
+                // Check for skill changes
+                const prevSkills = prevAgent.injected?.skills || [];
+                const currSkills = agent.injected?.skills || [];
+                const newSkills = currSkills.filter(s => !prevSkills.includes(s));
+                for (const skill of newSkills) {
+                    events.push(this.createEvent('skill_activated', agent, timestamp, skill));
+                }
+            }
+        }
+        // Check for session completion
+        const allCompleted = curr.agents.every(a => a.status === 'completed' || a.status === 'failed');
+        const wasActive = prev.agents.some(a => a.status === 'active');
+        if (allCompleted && wasActive && curr.agents.length > 0) {
+            events.push({
+                type: 'session_complete',
+                agentId: curr.gkSessionId,
+                targetAgentId: null,
+                skill: null,
+                message: 'All tasks completed',
+                timestamp,
+            });
+        }
+        return events;
+    }
+    /**
+     * Create event from agent
+     */
+    createEvent(type, agent, timestamp, skill) {
+        const messages = {
+            agent_idle: 'Waiting for work',
+            agent_working: 'Working...',
+            skill_activated: `Activated skill: ${skill || 'unknown'}`,
+            handoff_start: 'Passing work...',
+            handoff_complete: 'Handoff complete!',
+            received_work: 'Received work',
+            delivering: 'Delivering results...',
+            task_complete: 'Task complete!',
+            session_complete: 'All tasks completed',
+        };
+        return {
+            type,
+            agentId: agent.gkSessionId,
+            targetAgentId: agent.parentGkSessionId,
+            skill: skill || agent.injected?.skills?.[0] || null,
+            message: messages[type],
+            timestamp,
+            characterType: getCharacterType(agent.agentRole || 'coder'),
+        };
+    }
+}

package/dist/domains/agent-office/icons.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Icon mapping utilities for Agent Office
+ */
+/**
+ * Get icon for agent role
+ */
+export declare function getIconForRole(role: string, isOrchestrator?: boolean): string;
+/**
+ * Format role name for display
+ */
+export declare function formatDisplayName(role: string): string;

package/dist/domains/agent-office/icons.js

@@ -0,0 +1,36 @@
+/**
+ * Icon mapping utilities for Agent Office
+ */
+// Icon mapping by role keywords
+const ROLE_ICONS = [
+    [/research|search|analyze/i, '\uD83D\uDD0D'], // magnifier
+    [/code|implement|execute|develop/i, '\uD83D\uDCBB'], // laptop
+    [/plan|architect/i, '\uD83D\uDCCB'], // clipboard
+    [/debug|fix|troubleshoot/i, '\uD83D\uDC1B'], // bug
+    [/test|qa|quality/i, '\uD83E\uDDEA'], // test tube
+    [/design|ui|ux/i, '\uD83C\uDFA8'], // palette
+    [/review|audit|check/i, '\u2705'], // checkmark
+    [/doc|write|content/i, '\uD83D\uDCDD'], // memo
+];
+const DEFAULT_ICON = '\uD83E\uDD16'; // robot
+const ORCHESTRATOR_ICON = '\uD83D\uDC51'; // crown
+/**
+ * Get icon for agent role
+ */
+export function getIconForRole(role, isOrchestrator = false) {
+    if (isOrchestrator)
+        return ORCHESTRATOR_ICON;
+    for (const [pattern, icon] of ROLE_ICONS) {
+        if (pattern.test(role))
+            return icon;
+    }
+    return DEFAULT_ICON;
+}
+/**
+ * Format role name for display
+ */
+export function formatDisplayName(role) {
+    return role
+        .replace(/-/g, ' ')
+        .replace(/\b\w/g, c => c.toUpperCase());
+}

package/dist/domains/agent-office/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Agent Office domain exports
+ * Gamified visualization for multi-agent workflows
+ */
+export * from './types.js';
+export { createInitialState, isValidTransition, transitionAgent, processEvent, } from './state-machine.js';
+export { getIconForRole, formatDisplayName, } from './icons.js';
+export { sessionToOfficeState, agentToOfficeAgent, agentToInboxItem, isOrchestrator, } from './session-bridge.js';
+export { scanPlanDocuments, groupDocumentsByType, } from './documents-scanner.js';
+export { OfficeEventEmitter } from './event-emitter.js';
+export { SessionFileWatcher, type FileWatcherOptions } from './file-watcher.js';
+export { WebDashboard, startWebDashboard, type WebDashboardOptions } from './renderer/web.js';

package/dist/domains/agent-office/index.js

@@ -0,0 +1,20 @@
+/**
+ * Agent Office domain exports
+ * Gamified visualization for multi-agent workflows
+ */
+// Types
+export * from './types.js';
+// State machine
+export { createInitialState, isValidTransition, transitionAgent, processEvent, } from './state-machine.js';
+// Utilities
+export { getIconForRole, formatDisplayName, } from './icons.js';
+// Session bridge
+export { sessionToOfficeState, agentToOfficeAgent, agentToInboxItem, isOrchestrator, } from './session-bridge.js';
+// Documents
+export { scanPlanDocuments, groupDocumentsByType, } from './documents-scanner.js';
+// Event system
+export { OfficeEventEmitter } from './event-emitter.js';
+// File watcher
+export { SessionFileWatcher } from './file-watcher.js';
+// Renderers
+export { WebDashboard, startWebDashboard } from './renderer/web.js';

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

@@ -0,0 +1,11 @@
+/**
+ * Agent Office Gamified UI Assets
+ * Auto-generated by build.js - DO NOT EDIT MANUALLY
+ *
+ * To modify, edit the source files in:
+ * - src/core/ (base HTML, CSS, JS)
+ * - integrate-to-assets.js (gamified CSS, HTML, character JS)
+ *
+ * Then run: node build.js
+ */
+export declare function getIndexHtml(): string;