gemkit-cli 0.2.3 → 0.3.0

package/dist/domains/agent/profile.js

@@ -0,0 +1,225 @@
+/**
+ * Agent profile loading
+ */
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { join, basename } from 'path';
+import { getAgentsDir } from '../../utils/paths.js';
+import { getAgentPaths, mapModel, mapTools } from './mappings.js';
+/**
+ * Load a single agent profile by name
+ */
+export function loadAgentProfile(name, projectDir) {
+    const agentsDir = getAgentsDir(projectDir);
+    const filePath = join(agentsDir, `${name}.md`);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    return parseAgentProfile(filePath);
+}
+/**
+ * List all available agent profiles
+ */
+export function listAgentProfiles(projectDir) {
+    const agentsDir = getAgentsDir(projectDir);
+    if (!existsSync(agentsDir)) {
+        return [];
+    }
+    const files = readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+    const profiles = [];
+    for (const file of files) {
+        const filePath = join(agentsDir, file);
+        const profile = parseAgentProfile(filePath);
+        if (profile) {
+            profiles.push(profile);
+        }
+    }
+    return profiles;
+}
+/**
+ * Parse YAML frontmatter from markdown
+ */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return null;
+    const fm = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const idx = line.indexOf(':');
+        if (idx === -1)
+            continue;
+        const key = line.slice(0, idx).trim();
+        let val = line.slice(idx + 1).trim();
+        if ((val.startsWith('"') && val.endsWith('"')) || (val.startsWith("'") && val.endsWith("'"))) {
+            val = val.slice(1, -1);
+        }
+        fm[key] = val;
+    }
+    return fm;
+}
+/**
+ * Parse skills - handles single/multiple/array formats:
+ * - "research" -> ["research"]
+ * - "skill1, skill2" -> ["skill1", "skill2"]
+ * - "[skill1, skill2]" -> ["skill1", "skill2"]
+ */
+function parseSkills(value) {
+    if (!value)
+        return [];
+    let v = value.trim();
+    if (v.startsWith('[') && v.endsWith(']'))
+        v = v.slice(1, -1);
+    return v.split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+}
+/**
+ * Parse tools - handles single/multiple/array formats:
+ * - "read_file" -> ["read_file"]
+ * - "tool1, tool2" -> ["tool1", "tool2"]
+ * - "[tool1, tool2]" -> ["tool1", "tool2"]
+ */
+function parseTools(value) {
+    if (!value)
+        return [];
+    let v = value.trim();
+    if (v.startsWith('[') && v.endsWith(']'))
+        v = v.slice(1, -1);
+    return v.split(',').map(s => s.trim().replace(/['"]/g, '')).filter(Boolean);
+}
+/**
+ * Parse agent profile from markdown file
+ */
+function parseAgentProfile(filePath) {
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    const content = readFileSync(filePath, 'utf-8');
+    const name = basename(filePath, '.md');
+    let description = '';
+    let model = 'gemini-2.5-flash';
+    let skills = [];
+    let tools = [];
+    // Parse YAML frontmatter
+    const fm = parseFrontmatter(content);
+    let cleanContent = content;
+    if (fm) {
+        if (fm.description)
+            description = fm.description;
+        if (fm.model)
+            model = fm.model;
+        skills = parseSkills(fm.skills);
+        tools = parseTools(fm.tools);
+        // Strip frontmatter from content to avoid duplication
+        cleanContent = content.replace(/^---\r?\n[\s\S]*?\r?\n---\r?\n?/, '').trim();
+    }
+    else {
+        // Fallback: parse from content body
+        const lines = content.split('\n');
+        for (const line of lines) {
+            if (line.startsWith('# ')) {
+                description = line.substring(2).trim();
+                break;
+            }
+            if (line.trim() && !line.startsWith('#')) {
+                description = line.trim();
+                break;
+            }
+        }
+        const modelMatch = content.match(/model:\s*(.+)/i);
+        if (modelMatch)
+            model = modelMatch[1].trim();
+        const skillsMatch = content.match(/skills:\s*(.+)/i);
+        if (skillsMatch)
+            skills = parseSkills(skillsMatch[1]);
+        const toolsMatch = content.match(/tools:\s*(.+)/i);
+        if (toolsMatch)
+            tools = parseTools(toolsMatch[1]);
+    }
+    return {
+        name,
+        description,
+        model,
+        skills,
+        tools,
+        content: cleanContent,
+        filePath,
+    };
+}
+/**
+ * Get agent profile details as formatted string
+ */
+export function formatAgentProfile(profile) {
+    let output = `Agent: ${profile.name}\n`;
+    output += `Description: ${profile.description}\n`;
+    output += `Model: ${profile.model}\n`;
+    if (profile.skills && profile.skills.length > 0) {
+        output += `Skills: ${profile.skills.join(', ')}\n`;
+    }
+    if (profile.tools && profile.tools.length > 0) {
+        output += `Tools: ${profile.tools.join(', ')}\n`;
+    }
+    output += `Path: ${profile.filePath}\n`;
+    return output;
+}
+/**
+ * Load agent profile with fallback between providers
+ * Tries primary provider's folder first, then falls back to the other provider's folder
+ * Maps model and tools to target provider when using fallback
+ */
+export function loadAgentProfileWithFallback(name, targetProvider, projectDir) {
+    const cwd = projectDir || process.cwd();
+    const agentPaths = getAgentPaths(targetProvider);
+    for (const relPath of agentPaths) {
+        const filePath = join(cwd, relPath, `${name}.md`);
+        if (existsSync(filePath)) {
+            const profile = parseAgentProfile(filePath);
+            if (profile) {
+                // Check if this is from the fallback path (not the primary)
+                const isPrimaryPath = relPath === agentPaths[0];
+                if (!isPrimaryPath) {
+                    // Map model and tools to target provider
+                    profile.model = mapModel(profile.model, targetProvider);
+                    if (profile.tools && profile.tools.length > 0) {
+                        profile.tools = mapTools(profile.tools, targetProvider);
+                    }
+                }
+                return profile;
+            }
+        }
+    }
+    return null;
+}
+/**
+ * List all available agent profiles with fallback between providers
+ */
+export function listAgentProfilesWithFallback(targetProvider, projectDir) {
+    const cwd = projectDir || process.cwd();
+    const agentPaths = getAgentPaths(targetProvider);
+    const profiles = [];
+    const seenNames = new Set();
+    for (const relPath of agentPaths) {
+        const agentsDir = join(cwd, relPath);
+        if (!existsSync(agentsDir))
+            continue;
+        const files = readdirSync(agentsDir).filter(f => f.endsWith('.md'));
+        const isPrimaryPath = relPath === agentPaths[0];
+        for (const file of files) {
+            const name = basename(file, '.md');
+            // Skip if already found in primary path
+            if (seenNames.has(name))
+                continue;
+            seenNames.add(name);
+            const filePath = join(agentsDir, file);
+            const profile = parseAgentProfile(filePath);
+            if (profile) {
+                if (!isPrimaryPath) {
+                    // Map model and tools to target provider
+                    profile.model = mapModel(profile.model, targetProvider);
+                    if (profile.tools && profile.tools.length > 0) {
+                        profile.tools = mapTools(profile.tools, targetProvider);
+                    }
+                }
+                profiles.push(profile);
+            }
+        }
+    }
+    return profiles;
+}

package/dist/domains/agent/pty-context.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PTY Context Builder
+ * Builds enriched prompt for first send in interactive mode
+ * Reuses the same format as handleSpawn() for consistency
+ */
+import type { PtySessionState } from './pty-types.js';
+/**
+ * Build enriched prompt for first send
+ * Wraps task with agent, skills, and context - same format as spawn
+ */
+export declare function buildFirstSendPrompt(task: string, sessionState: PtySessionState): string;

package/dist/domains/agent/pty-context.js

@@ -0,0 +1,83 @@
+/**
+ * PTY Context Builder
+ * Builds enriched prompt for first send in interactive mode
+ * Reuses the same format as handleSpawn() for consistency
+ */
+/**
+ * Build subagent context string
+ */
+function buildSubagentContext(options) {
+    const { agentRole = 'Assistant', projectDir = null } = options;
+    const lines = [
+        `Agent Type: Interactive Session`,
+        `Agent Role: ${agentRole}`,
+    ];
+    if (projectDir) {
+        lines.push(`Project: ${projectDir}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Format context files section
+ */
+function formatContext(contextItems) {
+    if (!contextItems || contextItems.length === 0) {
+        return '';
+    }
+    let contextSection = '<context>\n';
+    contextSection += 'The following documents provide additional context for this task:\n\n';
+    contextItems.forEach((ctx, index) => {
+        contextSection += `## Document ${index + 1}: ${ctx.name}\n`;
+        contextSection += `Source: ${ctx.originalRef}\n\n`;
+        contextSection += ctx.content;
+        contextSection += '\n\n---\n\n';
+    });
+    contextSection += '</context>\n';
+    return contextSection;
+}
+/**
+ * Build enriched prompt for first send
+ * Wraps task with agent, skills, and context - same format as spawn
+ */
+export function buildFirstSendPrompt(task, sessionState) {
+    const promptParts = [];
+    // Add subagent context
+    const subagentContext = buildSubagentContext({
+        agentRole: sessionState.context.agentName || 'Assistant',
+        projectDir: process.cwd()
+    });
+    promptParts.push('<subagent-context>');
+    promptParts.push(subagentContext);
+    promptParts.push('</subagent-context>\n');
+    // Add task/prompt
+    promptParts.push('<task>');
+    promptParts.push(task);
+    promptParts.push('</task>\n');
+    // Add agent profile content
+    if (sessionState.context.agentName && sessionState.context.agentContent) {
+        promptParts.push('<agent>');
+        promptParts.push(`# Agent: ${sessionState.context.agentName}\n`);
+        promptParts.push('## Role & Responsibilities');
+        promptParts.push(sessionState.context.agentContent);
+        promptParts.push('</agent>\n');
+    }
+    // Add skills content
+    if (sessionState.context.skills.length > 0) {
+        promptParts.push('<skills>');
+        promptParts.push('You have access to the following skills and capabilities:\n');
+        sessionState.context.skills.forEach((skill, i) => {
+            const content = sessionState.context.skillContents[skill];
+            if (content) {
+                promptParts.push(`## Skill ${i + 1}: ${skill}`);
+                promptParts.push(content);
+                promptParts.push('---\n');
+            }
+        });
+        promptParts.push('</skills>\n');
+    }
+    // Add context section
+    if (sessionState.context.contextFiles.length > 0) {
+        promptParts.push(formatContext(sessionState.context.contextFiles));
+    }
+    return promptParts.join('\n');
+}

package/dist/domains/agent/pty-providers.d.ts

@@ -0,0 +1,18 @@
+/**
+ * PTY Provider Configurations
+ * Claude Code and Gemini CLI specific settings
+ */
+import type { PtyProviderConfig } from './pty-types.js';
+import type { CliProvider } from './types.js';
+/**
+ * Provider-specific configurations for PTY management
+ */
+export declare const PTY_PROVIDERS: Record<CliProvider, PtyProviderConfig>;
+/**
+ * Get provider config by name
+ */
+export declare function getProviderConfig(provider: CliProvider): PtyProviderConfig;
+/**
+ * Build CLI arguments for starting a PTY session
+ */
+export declare function buildPtyArgs(provider: CliProvider, model: string, tools: string[]): string[];

package/dist/domains/agent/pty-providers.js

@@ -0,0 +1,66 @@
+/**
+ * PTY Provider Configurations
+ * Claude Code and Gemini CLI specific settings
+ */
+/**
+ * Provider-specific configurations for PTY management
+ */
+export const PTY_PROVIDERS = {
+    claude: {
+        name: 'Claude Code',
+        command: 'claude',
+        modelFlag: '--model',
+        toolsFlag: '--allowedTools',
+        toolsFormat: 'csv', // Claude: --allowedTools Read,Write,Bash
+        pipeFlag: '-p', // Claude needs -p for stdin mode
+        readyIndicator: '❯', // Claude prompt indicator
+        responseMarker: '●', // Claude response marker
+        exitCommand: '/exit\r'
+    },
+    gemini: {
+        name: 'Gemini CLI',
+        command: 'gemini',
+        modelFlag: '-m',
+        toolsFlag: '--allowed-tools',
+        toolsFormat: 'json', // Gemini: --allowed-tools ["read_file","write_file"]
+        pipeFlag: undefined, // Gemini doesn't need -p
+        readyIndicator: '>', // Gemini prompt indicator
+        responseMarker: '✦', // Gemini response marker
+        exitCommand: '/exit\r'
+    }
+};
+/**
+ * Get provider config by name
+ */
+export function getProviderConfig(provider) {
+    const config = PTY_PROVIDERS[provider];
+    if (!config) {
+        throw new Error(`Unknown provider: ${provider}. Use 'claude' or 'gemini'`);
+    }
+    return config;
+}
+/**
+ * Build CLI arguments for starting a PTY session
+ */
+export function buildPtyArgs(provider, model, tools) {
+    const config = PTY_PROVIDERS[provider];
+    const args = [];
+    // Add pipe flag if needed (Claude)
+    if (config.pipeFlag) {
+        args.push(config.pipeFlag);
+    }
+    // Add model flag
+    args.push(config.modelFlag, model);
+    // Add tools if any
+    if (tools.length > 0) {
+        if (config.toolsFormat === 'json') {
+            // Gemini: --allowed-tools ["tool1","tool2"]
+            args.push(config.toolsFlag, JSON.stringify(tools));
+        }
+        else {
+            // Claude: --allowedTools tool1,tool2
+            args.push(config.toolsFlag, tools.join(','));
+        }
+    }
+    return args;
+}

package/dist/domains/agent/pty-session.d.ts

@@ -0,0 +1,33 @@
+/**
+ * PTY Session State Management
+ * Handles persistence of interactive session state
+ */
+import type { PtySessionState } from './pty-types.js';
+/**
+ * Get the session file path
+ */
+export declare function getSessionFilePath(cwd?: string): string;
+/**
+ * Load session state from file
+ */
+export declare function loadSession(cwd?: string): PtySessionState | null;
+/**
+ * Save session state to file
+ */
+export declare function saveSession(state: PtySessionState, cwd?: string): void;
+/**
+ * Clear session state file
+ */
+export declare function clearSession(cwd?: string): void;
+/**
+ * Check if a session is currently active (process running)
+ */
+export declare function isSessionActive(cwd?: string): boolean;
+/**
+ * Mark first send as complete
+ */
+export declare function markFirstSendComplete(cwd?: string): void;
+/**
+ * Update session PID after server starts
+ */
+export declare function updateSessionPid(pid: number, cwd?: string): void;

package/dist/domains/agent/pty-session.js

@@ -0,0 +1,82 @@
+/**
+ * PTY Session State Management
+ * Handles persistence of interactive session state
+ */
+import { existsSync, readFileSync, writeFileSync, unlinkSync } from 'fs';
+import { join } from 'path';
+const SESSION_FILE = '.gk-interactive-session.json';
+/**
+ * Get the session file path
+ */
+export function getSessionFilePath(cwd) {
+    return join(cwd || process.cwd(), SESSION_FILE);
+}
+/**
+ * Load session state from file
+ */
+export function loadSession(cwd) {
+    const filePath = getSessionFilePath(cwd);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Save session state to file
+ */
+export function saveSession(state, cwd) {
+    const filePath = getSessionFilePath(cwd);
+    writeFileSync(filePath, JSON.stringify(state, null, 2));
+}
+/**
+ * Clear session state file
+ */
+export function clearSession(cwd) {
+    const filePath = getSessionFilePath(cwd);
+    if (existsSync(filePath)) {
+        unlinkSync(filePath);
+    }
+}
+/**
+ * Check if a session is currently active (process running)
+ */
+export function isSessionActive(cwd) {
+    const session = loadSession(cwd);
+    if (!session)
+        return false;
+    // Check if process is still running
+    try {
+        process.kill(session.pid, 0);
+        return true;
+    }
+    catch {
+        // Process not running, clean up stale session
+        clearSession(cwd);
+        return false;
+    }
+}
+/**
+ * Mark first send as complete
+ */
+export function markFirstSendComplete(cwd) {
+    const session = loadSession(cwd);
+    if (session) {
+        session.isFirstSend = false;
+        saveSession(session, cwd);
+    }
+}
+/**
+ * Update session PID after server starts
+ */
+export function updateSessionPid(pid, cwd) {
+    const session = loadSession(cwd);
+    if (session) {
+        session.pid = pid;
+        saveSession(session, cwd);
+    }
+}

package/dist/domains/agent/pty-types.d.ts

@@ -0,0 +1,127 @@
+/**
+ * PTY Types for Interactive Mode
+ */
+import type { CliProvider } from './types.js';
+/**
+ * Provider-specific PTY configuration
+ */
+export interface PtyProviderConfig {
+    name: string;
+    command: string;
+    modelFlag: string;
+    toolsFlag: string;
+    toolsFormat: 'json' | 'csv';
+    pipeFlag?: string;
+    readyIndicator: string;
+    responseMarker: string;
+    exitCommand: string;
+}
+/**
+ * Loaded context file
+ */
+export interface LoadedContext {
+    type: 'context';
+    name: string;
+    path: string;
+    content: string;
+    originalRef: string;
+    relativePath?: string;
+}
+/**
+ * Session state stored in .gk-interactive-session.json
+ */
+export interface PtySessionState {
+    provider: CliProvider;
+    model: string;
+    port: number;
+    pid: number;
+    isFirstSend: boolean;
+    context: {
+        agentName: string | null;
+        agentContent: string | null;
+        skills: string[];
+        skillContents: Record<string, string>;
+        contextFiles: LoadedContext[];
+        tools: string[];
+    };
+    startedAt: string;
+}
+/**
+ * Structured exchange output
+ */
+export interface PtyExchange {
+    id: string;
+    timestamp: string;
+    prompt: string;
+    answer: string;
+    pending: PtyPendingTool[];
+    toolResults: PtyToolResult[];
+    status: 'complete' | 'waiting_confirmation' | 'streaming';
+}
+/**
+ * Pending tool awaiting confirmation
+ */
+export interface PtyPendingTool {
+    type: 'shell' | 'write_file' | 'read_file' | 'read_folder' | 'edit_file' | 'apply_change';
+    detail?: string;
+    command?: string;
+    path?: string;
+    waiting: boolean;
+    options?: string[];
+    actionRequired?: {
+        current: number;
+        total: number;
+    };
+}
+/**
+ * Tool execution result
+ */
+export interface PtyToolResult {
+    type: string;
+    detail: string;
+    status: 'completed' | 'failed' | 'in_progress';
+}
+/**
+ * Real-time event from PTY stream
+ */
+export interface PtyEvent {
+    type: 'stream_started' | 'tool_in_progress' | 'tool_completed' | 'tool_failed' | 'tool_confirmation_required' | 'action_required' | 'waiting_confirmation' | 'response_chunk' | 'prompt_ready';
+    tool?: string;
+    detail?: string;
+    command?: string;
+    current?: number;
+    total?: number;
+}
+/**
+ * Server status response
+ */
+export interface PtyServerStatus {
+    running: boolean;
+    ready: boolean;
+    provider: CliProvider;
+    outputLength: number;
+}
+/**
+ * Send command response
+ */
+export interface PtySendResponse {
+    ok: boolean;
+    exchangeId?: string;
+    error?: string;
+}
+/**
+ * Completion check response
+ */
+export interface PtyCompleteResponse {
+    complete: boolean;
+    reason?: 'streaming' | 'no_response' | 'pending_tool' | 'waiting_content' | 'unknown';
+    hint?: string;
+}
+/**
+ * Pending tools response
+ */
+export interface PtyPendingResponse {
+    hasPending: boolean;
+    tools: PtyPendingTool[];
+    hint?: string;
+}

package/dist/domains/agent/pty-types.js

@@ -0,0 +1,4 @@
+/**
+ * PTY Types for Interactive Mode
+ */
+export {};

package/dist/domains/agent/search.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Agent-Skill Composer Search - BM25 search engine for Agent+Skills combinations
+ * Ported from Python core.py with same logic
+ */
+import { SearchResult, Intent, Domain, Complexity, SkillInfo } from './types.js';
+declare const COMPLEXITY_MAX_SKILLS: Record<Complexity, number>;
+declare const INTENT_AGENT_MAP: Record<Intent, string>;
+declare const DOMAIN_SKILL_MAP: Record<string, string[]>;
+declare function loadSynonyms(): Map<string, string[]>;
+declare function expandQuery(query: string, synonyms?: Map<string, string[]>): string;
+export declare function detectComplexity(query: string): Complexity;
+export declare function detectIntent(query: string): Intent;
+export declare function detectDomain(query: string): Domain;
+export declare function searchCombinations(query: string, maxResults?: number, expand?: boolean): {
+    query: string;
+    expandedQuery?: string;
+    detectedIntent: Intent;
+    detectedDomain: Domain;
+    detectedComplexity: Complexity;
+    count: number;
+    results: Array<Record<string, any>>;
+};
+export declare function searchCombinationsFiltered(query: string, intentFilter?: Intent, domainFilter?: Domain, maxResults?: number, expand?: boolean): {
+    results: Array<Record<string, any>>;
+    count: number;
+};
+export declare function getBestCombination(query: string): SearchResult;
+/**
+ * Main search function - returns multiple results
+ */
+export declare function searchAgentSkillCombination(task: string, options?: {
+    top?: number;
+    forceIntent?: Intent;
+    forceDomain?: Domain;
+    maxSkills?: number;
+}): SearchResult[];
+/**
+ * List all available skills from extensions
+ */
+export declare function listAllSkills(projectDir?: string): SkillInfo[];
+/**
+ * Load skill content by name
+ */
+export declare function loadSkillContent(skillName: string, projectDir?: string): string | null;
+export { loadSynonyms, expandQuery, INTENT_AGENT_MAP, DOMAIN_SKILL_MAP, COMPLEXITY_MAX_SKILLS };