gemkit-cli 0.2.3 → 0.3.0

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

@@ -0,0 +1,8 @@
+/**
+ * Session domain exports
+ */
+export * from './types.js';
+export * from './env.js';
+export * from './paths.js';
+export * from './manager.js';
+export * from './writer.js';

package/dist/domains/session/index.js

@@ -0,0 +1,8 @@
+/**
+ * Session domain exports
+ */
+export * from './types.js';
+export * from './env.js';
+export * from './paths.js';
+export * from './manager.js';
+export * from './writer.js';

package/dist/domains/session/manager.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Session manager - READ-ONLY operations
+ * Reads session data created by gk-session-manager.cjs hooks
+ *
+ * Storage: ~/.gemkit/projects/{projectDir}/gk-session-{gkSessionId}.json
+ */
+import { GkSession, GkAgent, GkProject, SessionListOptions, AgentFilterOptions, SessionMetrics } from './types.js';
+/**
+ * Get session by ID
+ * Matches gk-session-manager.cjs getSession()
+ */
+export declare function getSession(projectDir: string, gkSessionId: string): GkSession | null;
+/**
+ * Get current active session
+ */
+export declare function getActiveSession(): GkSession | null;
+/**
+ * Check if session exists
+ */
+export declare function sessionExists(projectDir: string, gkSessionId: string): boolean;
+/**
+ * List all sessions for a project
+ */
+export declare function listSessions(projectDir: string, options?: SessionListOptions): GkSession[];
+/**
+ * List all projects
+ */
+export declare function listProjects(): string[];
+/**
+ * Get project metadata
+ * Matches gk-session-manager.cjs getProject()
+ */
+export declare function getProject(projectDir: string, gkProjectHash: string): GkProject | null;
+/**
+ * Get agents from session
+ * Matches gk-session-manager.cjs getAgents()
+ */
+export declare function getAgents(projectDir: string, gkSessionId: string, filters?: AgentFilterOptions): GkAgent[];
+/**
+ * Get session metrics
+ * Matches gk-session-manager.cjs getMetrics()
+ */
+export declare function getMetrics(projectDir: string, gkSessionId: string): SessionMetrics;
+/**
+ * Find session by Gemini session ID
+ * Matches gk-session-manager.cjs findSessionByGeminiId()
+ */
+export declare function findSessionByGeminiId(projectDir: string, geminiSessionId: string): GkSession | null;
+/**
+ * Get sub-agents from current session
+ */
+export declare function getSubAgents(projectDir: string, gkSessionId: string): GkAgent[];
+/**
+ * Get main agent from session
+ */
+export declare function getMainAgent(projectDir: string, gkSessionId: string): GkAgent | null;

package/dist/domains/session/manager.js

@@ -0,0 +1,205 @@
+/**
+ * Session manager - READ-ONLY operations
+ * Reads session data created by gk-session-manager.cjs hooks
+ *
+ * Storage: ~/.gemkit/projects/{projectDir}/gk-session-{gkSessionId}.json
+ */
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join } from 'path';
+import { getProjectDataDir, getSessionPath, getProjectPath, GEMKIT_PROJECTS_DIR } from '../../utils/paths.js';
+import { getProjectDir, getActiveGkSessionId } from './env.js';
+/**
+ * Get session by ID
+ * Matches gk-session-manager.cjs getSession()
+ */
+export function getSession(projectDir, gkSessionId) {
+    if (!projectDir || !gkSessionId)
+        return null;
+    const sessionPath = getSessionPath(projectDir, gkSessionId);
+    if (!existsSync(sessionPath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(sessionPath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Get current active session
+ */
+export function getActiveSession() {
+    const projectDir = getProjectDir();
+    const gkSessionId = getActiveGkSessionId();
+    if (!gkSessionId)
+        return null;
+    return getSession(projectDir, gkSessionId);
+}
+/**
+ * Check if session exists
+ */
+export function sessionExists(projectDir, gkSessionId) {
+    if (!projectDir || !gkSessionId)
+        return false;
+    return existsSync(getSessionPath(projectDir, gkSessionId));
+}
+/**
+ * List all sessions for a project
+ */
+export function listSessions(projectDir, options = {}) {
+    const { limit = 10, status = 'all' } = options;
+    const projectDataDir = getProjectDataDir(projectDir);
+    if (!existsSync(projectDataDir)) {
+        return [];
+    }
+    const sessions = [];
+    try {
+        const files = readdirSync(projectDataDir)
+            .filter(f => f.startsWith('gk-session-') && f.endsWith('.json'));
+        for (const file of files) {
+            const filePath = join(projectDataDir, file);
+            const content = readFileSync(filePath, 'utf-8');
+            const session = JSON.parse(content);
+            // Filter by status
+            if (status !== 'all') {
+                const mainAgent = session.agents?.find(a => a.agentType === 'Main Agent');
+                const sessionStatus = mainAgent?.status || 'active';
+                if (sessionStatus !== status)
+                    continue;
+            }
+            sessions.push(session);
+        }
+    }
+    catch (e) {
+        // Return empty on error
+    }
+    // Sort by initTimestamp, newest first
+    sessions.sort((a, b) => new Date(b.initTimestamp).getTime() - new Date(a.initTimestamp).getTime());
+    return sessions.slice(0, limit);
+}
+/**
+ * List all projects
+ */
+export function listProjects() {
+    if (!existsSync(GEMKIT_PROJECTS_DIR)) {
+        return [];
+    }
+    try {
+        return readdirSync(GEMKIT_PROJECTS_DIR, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+    }
+    catch (e) {
+        return [];
+    }
+}
+/**
+ * Get project metadata
+ * Matches gk-session-manager.cjs getProject()
+ */
+export function getProject(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 (e) {
+        return null;
+    }
+}
+/**
+ * Get agents from session
+ * Matches gk-session-manager.cjs getAgents()
+ */
+export function getAgents(projectDir, gkSessionId, filters = {}) {
+    const session = getSession(projectDir, gkSessionId);
+    if (!session || !session.agents)
+        return [];
+    let agents = session.agents;
+    if (filters.agentType) {
+        agents = agents.filter(a => a.agentType === filters.agentType);
+    }
+    if (filters.status) {
+        agents = agents.filter(a => a.status === filters.status);
+    }
+    return agents;
+}
+/**
+ * Get session metrics
+ * Matches gk-session-manager.cjs getMetrics()
+ */
+export function getMetrics(projectDir, gkSessionId) {
+    const agents = getAgents(projectDir, gkSessionId);
+    const metrics = {
+        total: agents.length,
+        active: 0,
+        completed: 0,
+        failed: 0,
+        mainAgents: 0,
+        subAgents: 0,
+        totalDurationMs: 0
+    };
+    agents.forEach(agent => {
+        if (agent.status === 'active')
+            metrics.active++;
+        else if (agent.status === 'completed')
+            metrics.completed++;
+        else if (agent.status === 'failed')
+            metrics.failed++;
+        if (agent.agentType === 'Main Agent')
+            metrics.mainAgents++;
+        else
+            metrics.subAgents++;
+        if (agent.startTime && agent.endTime) {
+            metrics.totalDurationMs += new Date(agent.endTime).getTime() - new Date(agent.startTime).getTime();
+        }
+    });
+    return metrics;
+}
+/**
+ * Find session by Gemini session ID
+ * Matches gk-session-manager.cjs findSessionByGeminiId()
+ */
+export function findSessionByGeminiId(projectDir, geminiSessionId) {
+    if (!projectDir || !geminiSessionId)
+        return null;
+    const projectDataDir = getProjectDataDir(projectDir);
+    if (!existsSync(projectDataDir))
+        return null;
+    try {
+        const files = readdirSync(projectDataDir)
+            .filter(f => f.startsWith('gk-session-') && f.endsWith('.json'));
+        for (const file of files) {
+            const filePath = join(projectDataDir, file);
+            const content = readFileSync(filePath, 'utf-8');
+            const session = JSON.parse(content);
+            if (session.geminiSessionId === geminiSessionId) {
+                return session;
+            }
+        }
+    }
+    catch (e) {
+        // Ignore errors
+    }
+    return null;
+}
+/**
+ * Get sub-agents from current session
+ */
+export function getSubAgents(projectDir, gkSessionId) {
+    return getAgents(projectDir, gkSessionId, { agentType: 'Sub Agent' });
+}
+/**
+ * Get main agent from session
+ */
+export function getMainAgent(projectDir, gkSessionId) {
+    const agents = getAgents(projectDir, gkSessionId, { agentType: 'Main Agent' });
+    return agents[0] || null;
+}

package/dist/domains/session/paths.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Session path utilities
+ * Re-exports from utils/paths.ts for backwards compatibility
+ * Aligned with gk-session-manager.cjs
+ */
+export { GEMKIT_PROJECTS_DIR, getProjectDataDir, getSessionPath, getProjectPath, sanitizeProjectPath } from '../../utils/paths.js';

package/dist/domains/session/paths.js

@@ -0,0 +1,6 @@
+/**
+ * Session path utilities
+ * Re-exports from utils/paths.ts for backwards compatibility
+ * Aligned with gk-session-manager.cjs
+ */
+export { GEMKIT_PROJECTS_DIR, getProjectDataDir, getSessionPath, getProjectPath, sanitizeProjectPath } from '../../utils/paths.js';

package/dist/domains/session/types.d.ts

@@ -0,0 +1,121 @@
+/**
+ * Session type definitions
+ * Aligned with gk-session-manager.cjs session structure
+ */
+/**
+ * GK Session - matches gk-session-manager.cjs session structure
+ */
+export interface GkSession {
+    gkSessionId: string;
+    gkProjectHash: string;
+    projectDir: string;
+    geminiSessionId: string | null;
+    geminiParentId: string | null;
+    geminiProjectHash: string | null;
+    geminiTempDir?: string;
+    initialized: boolean;
+    initTimestamp: string;
+    sessionType: 'gemini' | 'non-gemini';
+    appName: string;
+    pid: number;
+    activePlan: string | null;
+    suggestedPlan: string | null;
+    planDateFormat?: string;
+    agents: GkAgent[];
+}
+/**
+ * GK Agent - matches gk-session-manager.cjs agent structure
+ */
+export interface GkAgent {
+    gkSessionId: string;
+    pid: number | null;
+    geminiSessionId: string | null;
+    geminiProjectHash: string | null;
+    parentGkSessionId: string | null;
+    agentType: 'Main Agent' | 'Sub Agent';
+    agentRole: string;
+    prompt: string | null;
+    model: string | null;
+    tokenUsage: TokenUsage | null;
+    retryCount: number;
+    resumeCount: number;
+    generation: number;
+    injected: InjectedContext | null;
+    startTime: string;
+    endTime: string | null;
+    status: 'active' | 'completed' | 'failed';
+    exitCode: number | null;
+    error: string | null;
+}
+/**
+ * Token usage structure
+ */
+export interface TokenUsage {
+    input: number;
+    output: number;
+    cached: number;
+    thoughts: number;
+    tool: number;
+    total: number;
+}
+/**
+ * Injected context tracking
+ */
+export interface InjectedContext {
+    skills: string[];
+    context: string[];
+    contextHash?: string;
+}
+/**
+ * GK Project - matches gk-session-manager.cjs project structure
+ */
+export interface GkProject {
+    gkProjectHash: string;
+    projectDir: string;
+    projectPath: string;
+    geminiProjectHash: string | null;
+    initialized: boolean;
+    initTimestamp: string;
+    lastActiveTimestamp: string;
+    activeGkSessionId: string | null;
+    sessions: GkProjectSession[];
+}
+/**
+ * Session summary in project file
+ */
+export interface GkProjectSession {
+    gkSessionId: string;
+    pid: number | null;
+    sessionType: 'gemini' | 'non-gemini';
+    appName: string;
+    prompt: string | null;
+    activePlan: string | null;
+    startTime: string;
+    endTime: string | null;
+}
+/**
+ * Session list options
+ */
+export interface SessionListOptions {
+    limit?: number;
+    status?: 'active' | 'completed' | 'failed' | 'all';
+}
+/**
+ * Agent filter options
+ */
+export interface AgentFilterOptions {
+    agentType?: 'Main Agent' | 'Sub Agent';
+    status?: 'active' | 'completed' | 'failed';
+}
+/**
+ * Session metrics
+ */
+export interface SessionMetrics {
+    total: number;
+    active: number;
+    completed: number;
+    failed: number;
+    mainAgents: number;
+    subAgents: number;
+    totalDurationMs: number;
+}

package/dist/domains/session/types.js

@@ -0,0 +1,5 @@
+/**
+ * Session type definitions
+ * Aligned with gk-session-manager.cjs session structure
+ */
+export {};

package/dist/domains/session/writer.d.ts

@@ -0,0 +1,82 @@
+/**
+ * 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 { GkSession, GkAgent, GkProject, GkProjectSession } from './types.js';
+/**
+ * Get the terminal PID by walking up the process tree
+ * Matches gk-session-manager.cjs getTerminalPid()
+ */
+export declare function getTerminalPid(): number;
+/**
+ * Save session to file (atomic write)
+ * Matches gk-session-manager.cjs saveSession()
+ */
+export declare function saveSession(projectDir: string, gkSessionId: string, data: GkSession): boolean;
+/**
+ * Update .gemini/.env with session and project info
+ * Matches gk-session-manager.cjs updateEnv()
+ */
+export declare function updateEnv(envData: {
+    gkSessionId?: string;
+    gkProjectHash?: string;
+    projectDir?: string;
+    geminiSessionId?: string;
+    geminiProjectHash?: string;
+    activePlan?: string;
+    suggestedPlan?: string;
+    planDateFormat?: string;
+}): boolean;
+/**
+ * Save project data
+ */
+export declare function saveProject(projectDir: string, gkProjectHash: string, data: GkProject): boolean;
+/**
+ * Create or get project
+ */
+export declare function ensureProject(projectDir: string, gkProjectHash: string, projectPath?: string): GkProject;
+/**
+ * Add session summary to project
+ */
+export declare function addSessionToProject(projectDir: string, gkProjectHash: string, sessionSummary: Partial<GkProjectSession> & {
+    gkSessionId: string;
+}): boolean;
+/**
+ * Add agent to session
+ * Matches gk-session-manager.cjs addAgent()
+ */
+export declare function addAgent(projectDir: string, gkSessionId: string, agentData: Partial<GkAgent>): boolean;
+/**
+ * Initialize a non-Gemini session
+ * Matches gk-session-manager.cjs initializeNonGeminiSession()
+ */
+export declare function initializeNonGeminiSession(appName: string, options?: {
+    cwd?: string;
+    activePlan?: string | null;
+    suggestedPlan?: string | null;
+}): {
+    session: GkSession;
+    gkSessionId: string;
+    pid: number;
+    projectDir: string;
+    gkProjectHash: string;
+};
+/**
+ * Set active plan in session and .env
+ * Matches gk-session-manager.cjs setActivePlan()
+ */
+export declare function setActivePlan(projectDir: string, gkSessionId: string, planPath: string): boolean;
+/**
+ * Parse gkSessionId to extract components
+ * Matches gk-session-manager.cjs parseGkSessionId()
+ */
+export declare function parseGkSessionId(gkSessionId: string): {
+    appName: string;
+    pid: number;
+    timestamp: string;
+    random: string;
+} | null;