gemkit-cli 0.2.2 → 0.3.0

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

@@ -0,0 +1,91 @@
+/**
+ * Agent Office type definitions
+ */
+export type AgentState = 'idle' | 'working' | 'walking' | 'delivering' | 'receiving';
+export type CharacterType = 'orchestrator' | 'researcher' | 'coder' | 'planner' | 'tester' | 'designer' | 'other' | 'reviewer' | 'artist' | 'writer' | 'manager';
+export interface CharacterPosition {
+    x: number;
+    y: number;
+    desk: string;
+    facing: 'left' | 'right' | 'front';
+}
+export type AnimationState = 'idle' | 'typing' | 'walking' | 'celebrating';
+export interface OfficeAgent {
+    id: string;
+    agentType: 'orchestrator' | 'sub-agent';
+    role: string;
+    characterType?: CharacterType;
+    icon: string;
+    state: AgentState;
+    activeSkill: string | null;
+    progress: number;
+    speechBubble: string | null;
+    hasFireEffect: boolean;
+    gkSessionId: string;
+    parentSessionId: string | null;
+}
+export interface OrchestratorAgent extends OfficeAgent {
+    agentType: 'orchestrator';
+    delegatedTo: string[];
+    totalSubAgents: number;
+    completedSubAgents: number;
+}
+export interface OfficeEvent {
+    type: OfficeEventType;
+    agentId: string;
+    targetAgentId: string | null;
+    skill: string | null;
+    message: string;
+    timestamp: number;
+    characterType?: CharacterType;
+}
+export type OfficeEventType = 'agent_idle' | 'agent_working' | 'skill_activated' | 'handoff_start' | 'handoff_complete' | 'received_work' | 'delivering' | 'task_complete' | 'session_complete';
+export interface InboxItem {
+    id: string;
+    agentId: string;
+    agentRole: string;
+    agentIcon: string;
+    timestamp: number;
+    status: 'unread' | 'read';
+    title: string;
+    preview: string;
+    fullContent: string | null;
+    tokenUsage: {
+        input: number;
+        output: number;
+    } | null;
+    duration: number;
+    skillsUsed: string[];
+}
+export interface PlanDocument {
+    id: string;
+    name: string;
+    displayName: string;
+    type: DocumentType;
+    icon: string;
+    path: string;
+    relativePath: string;
+    modifiedAt: number;
+    createdAt: number;
+    size: number;
+    extension: string;
+    phaseNumber: number | null;
+}
+export type DocumentType = 'plan' | 'phase' | 'research' | 'artifact' | 'report' | 'other';
+export interface OfficeState {
+    orchestrator: OrchestratorAgent | null;
+    agents: Map<string, OfficeAgent>;
+    sessionId: string | null;
+    projectDir: string | null;
+    activePlan: string | null;
+    appName: string | null;
+    currentNotification: OfficeNotification | null;
+    inbox: InboxItem[];
+    documents: PlanDocument[];
+    isActive: boolean;
+}
+export interface OfficeNotification {
+    message: string;
+    type: 'skill' | 'handoff' | 'success' | 'info';
+    timestamp: number;
+}

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

@@ -0,0 +1,4 @@
+/**
+ * Agent Office type definitions
+ */
+export {};

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

@@ -0,0 +1 @@
+export * from './manager.js';

package/dist/domains/cache/index.js

@@ -0,0 +1 @@
+export * from './manager.js';

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

@@ -0,0 +1,22 @@
+/**
+ * Cache manager for releases
+ */
+/**
+ * Get cached value
+ */
+export declare function getCache<T>(key: string): T | null;
+/**
+ * Set cached value
+ */
+export declare function setCache<T>(key: string, data: T, ttl?: number): void;
+/**
+ * Clear all cache
+ */
+export declare function clearCache(): number;
+/**
+ * Get cache stats
+ */
+export declare function getCacheStats(): {
+    entries: number;
+    size: number;
+};

package/dist/domains/cache/manager.js

@@ -0,0 +1,84 @@
+/**
+ * Cache manager for releases
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync, readdirSync, unlinkSync, statSync } from 'fs';
+import { join } from 'path';
+import { GEMKIT_CACHE_DIR } from '../../utils/paths.js';
+/**
+ * Get cache directory path
+ */
+function getCacheDir() {
+    if (!existsSync(GEMKIT_CACHE_DIR)) {
+        mkdirSync(GEMKIT_CACHE_DIR, { recursive: true });
+    }
+    return GEMKIT_CACHE_DIR;
+}
+/**
+ * Get cache file path for key
+ */
+function getCacheFilePath(key) {
+    const safeKey = key.replace(/[^a-zA-Z0-9-_]/g, '_');
+    return join(getCacheDir(), `${safeKey}.json`);
+}
+/**
+ * Get cached value
+ */
+export function getCache(key) {
+    const filePath = getCacheFilePath(key);
+    if (!existsSync(filePath)) {
+        return null;
+    }
+    try {
+        const content = readFileSync(filePath, 'utf-8');
+        const entry = JSON.parse(content);
+        // Check if expired
+        if (Date.now() - entry.timestamp > entry.ttl * 1000) {
+            unlinkSync(filePath);
+            return null;
+        }
+        return entry.data;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Set cached value
+ */
+export function setCache(key, data, ttl = 3600) {
+    const filePath = getCacheFilePath(key);
+    const entry = {
+        key,
+        data,
+        timestamp: Date.now(),
+        ttl,
+    };
+    writeFileSync(filePath, JSON.stringify(entry, null, 2));
+}
+/**
+ * Clear all cache
+ */
+export function clearCache() {
+    const cacheDir = getCacheDir();
+    const files = readdirSync(cacheDir).filter(f => f.endsWith('.json'));
+    for (const file of files) {
+        unlinkSync(join(cacheDir, file));
+    }
+    return files.length;
+}
+/**
+ * Get cache stats
+ */
+export function getCacheStats() {
+    const cacheDir = getCacheDir();
+    const files = readdirSync(cacheDir).filter(f => f.endsWith('.json'));
+    let totalSize = 0;
+    for (const file of files) {
+        const stat = statSync(join(cacheDir, file));
+        totalSize += stat.size;
+    }
+    return {
+        entries: files.length,
+        size: totalSize,
+    };
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Config domain exports
+ */
+export * from './schema.js';
+export * from './manager.js';

package/dist/domains/config/index.js

@@ -0,0 +1,5 @@
+/**
+ * Config domain exports
+ */
+export * from './schema.js';
+export * from './manager.js';

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

@@ -0,0 +1,24 @@
+/**
+ * Configuration manager
+ */
+import type { GemKitConfig } from '../../types/index.js';
+/**
+ * Load configuration from file
+ */
+export declare function loadConfig(projectDir?: string): GemKitConfig;
+/**
+ * Save configuration to file
+ */
+export declare function saveConfig(config: GemKitConfig, projectDir?: string): void;
+/**
+ * Get a specific config value by path
+ */
+export declare function getConfigValue(path: string, projectDir?: string): unknown;
+/**
+ * Set a specific config value by path
+ */
+export declare function setConfigValue(path: string, value: unknown, projectDir?: string): void;
+/**
+ * Reset config to defaults
+ */
+export declare function resetConfig(projectDir?: string): void;

package/dist/domains/config/manager.js

@@ -0,0 +1,85 @@
+/**
+ * Configuration manager
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'fs';
+import { dirname } from 'path';
+import { getLocalConfigPath } from '../../utils/paths.js';
+import { DEFAULT_CONFIG, mergeConfig, validateConfig } from './schema.js';
+import { ConfigError } from '../../utils/errors.js';
+/**
+ * Load configuration from file
+ */
+export function loadConfig(projectDir) {
+    const configPath = getLocalConfigPath(projectDir);
+    if (!existsSync(configPath)) {
+        return DEFAULT_CONFIG;
+    }
+    try {
+        const content = readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (!validateConfig(parsed)) {
+            throw new ConfigError('Invalid configuration format');
+        }
+        return mergeConfig(parsed);
+    }
+    catch (error) {
+        if (error instanceof ConfigError) {
+            throw error;
+        }
+        throw new ConfigError(`Failed to load config: ${error}`);
+    }
+}
+/**
+ * Save configuration to file
+ */
+export function saveConfig(config, projectDir) {
+    const configPath = getLocalConfigPath(projectDir);
+    const dir = dirname(configPath);
+    if (!existsSync(dir)) {
+        mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+/**
+ * Get a specific config value by path
+ */
+export function getConfigValue(path, projectDir) {
+    const config = loadConfig(projectDir);
+    const keys = path.split('.');
+    let value = config;
+    for (const key of keys) {
+        if (value && typeof value === 'object' && key in value) {
+            value = value[key];
+        }
+        else {
+            return undefined;
+        }
+    }
+    return value;
+}
+/**
+ * Set a specific config value by path
+ */
+export function setConfigValue(path, value, projectDir) {
+    const config = loadConfig(projectDir);
+    const keys = path.split('.');
+    const lastKey = keys.pop();
+    if (!lastKey) {
+        throw new ConfigError('Invalid config path');
+    }
+    let obj = config;
+    for (const key of keys) {
+        if (!(key in obj) || typeof obj[key] !== 'object') {
+            obj[key] = {};
+        }
+        obj = obj[key];
+    }
+    obj[lastKey] = value;
+    saveConfig(config, projectDir);
+}
+/**
+ * Reset config to defaults
+ */
+export function resetConfig(projectDir) {
+    saveConfig(DEFAULT_CONFIG, projectDir);
+}

package/dist/domains/config/schema.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Configuration schema for GemKit CLI
+ */
+import type { GemKitConfig } from '../../types/index.js';
+/**
+ * Default configuration - uses starter repo
+ */
+export declare const DEFAULT_CONFIG: GemKitConfig;
+/**
+ * Validate configuration object
+ * Only validates it's a valid object - mergeConfig handles defaults
+ */
+export declare function validateConfig(config: unknown): config is GemKitConfig;
+/**
+ * Merge partial config with defaults
+ */
+export declare function mergeConfig(partial: Partial<GemKitConfig>): GemKitConfig;

package/dist/domains/config/schema.js

@@ -0,0 +1,96 @@
+/**
+ * Configuration schema for GemKit CLI
+ */
+/**
+ * Default configuration - uses starter repo
+ */
+export const DEFAULT_CONFIG = {
+    defaultScope: 'local',
+    github: {
+        repo: 'therichardngai-code/gemkit-kits-starter',
+        apiUrl: 'https://api.github.com',
+    },
+    cache: {
+        enabled: true,
+        ttl: 3600,
+    },
+    installation: {
+        excludePatterns: [],
+        backupOnUpdate: true,
+    },
+    ui: {
+        colors: true,
+        spinner: true,
+        verbose: false,
+    },
+    paths: {},
+    spawn: {
+        defaultModel: 'gemini-2.5-flash',
+        music: false,
+    },
+    office: {
+        enabled: true,
+        mode: 'web',
+        port: 3847,
+        autoOpen: true,
+        sounds: false,
+        refreshRate: 500,
+    },
+    update: {
+        autoCheck: true,
+        checkInterval: 24, // hours
+        notifyOnly: true, // only notify, don't auto-update
+    },
+};
+/**
+ * Validate configuration object
+ * Only validates it's a valid object - mergeConfig handles defaults
+ */
+export function validateConfig(config) {
+    if (!config || typeof config !== 'object') {
+        return false;
+    }
+    // No strict field requirements - mergeConfig fills in defaults
+    return true;
+}
+/**
+ * Merge partial config with defaults
+ */
+export function mergeConfig(partial) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...partial,
+        github: {
+            ...DEFAULT_CONFIG.github,
+            ...(partial.github || {}),
+        },
+        cache: {
+            ...DEFAULT_CONFIG.cache,
+            ...(partial.cache || {}),
+        },
+        installation: {
+            ...DEFAULT_CONFIG.installation,
+            ...(partial.installation || {}),
+        },
+        ui: {
+            ...DEFAULT_CONFIG.ui,
+            ...(partial.ui || {}),
+        },
+        paths: {
+            ...DEFAULT_CONFIG.paths,
+            ...(partial.paths || {}),
+        },
+        spawn: {
+            ...DEFAULT_CONFIG.spawn,
+            ...(partial.spawn || {}),
+        },
+        office: {
+            ...DEFAULT_CONFIG.office,
+            ...(partial.office || {}),
+        },
+        update: {
+            ...DEFAULT_CONFIG.update,
+            ...(partial.update || {}),
+        },
+    };
+}

package/dist/domains/convert/converter.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Skill to Extension Converter
+ * Converts .claude/skills to .gemini/extensions
+ */
+import { SkillFrontmatter, GeminiExtension, SkillInfo, ConversionResult, ConvertOptions, AgentFrontmatter, AgentInfo } from './types.js';
+/**
+ * Parse YAML-like frontmatter from markdown file
+ */
+export declare function parseFrontmatter(content: string): SkillFrontmatter | null;
+/**
+ * Get skills directory path
+ */
+export declare function getSkillsDir(projectDir?: string): string;
+/**
+ * Get extensions directory path
+ */
+export declare function getExtensionsDir(projectDir?: string): string;
+/**
+ * List all available Claude skills
+ */
+export declare function listSkills(projectDir?: string): SkillInfo[];
+/**
+ * Check if an extension already exists
+ */
+export declare function extensionExists(name: string, projectDir?: string): boolean;
+/**
+ * Generate gemini-extension.json content
+ */
+export declare function generateExtensionJson(frontmatter: SkillFrontmatter, hasReferences: boolean): GeminiExtension;
+/**
+ * Convert a single skill to extension
+ */
+export declare function convertSkill(skillName: string, options?: ConvertOptions, projectDir?: string): ConversionResult;
+/**
+ * Convert all skills to extensions
+ */
+export declare function convertAllSkills(options?: ConvertOptions, projectDir?: string): ConversionResult[];
+/**
+ * Get conversion summary
+ */
+export declare function getConversionSummary(results: ConversionResult[]): {
+    total: number;
+    success: number;
+    skipped: number;
+    failed: number;
+};
+/**
+ * Get Claude agents directory path
+ */
+export declare function getClaudeAgentsDir(projectDir?: string): string;
+/**
+ * Get Gemini agents directory path
+ */
+export declare function getGeminiAgentsDir(projectDir?: string): string;
+/**
+ * Parse agent frontmatter
+ */
+export declare function parseAgentFrontmatter(content: string): AgentFrontmatter | null;
+/**
+ * List all available Claude agents
+ */
+export declare function listAgents(projectDir?: string): AgentInfo[];
+/**
+ * Check if an agent already exists in Gemini
+ */
+export declare function geminiAgentExists(name: string, projectDir?: string): boolean;
+/**
+ * Map Claude model to Gemini model
+ */
+export declare function mapModel(model: string | undefined): string | undefined;
+/**
+ * Convert a single agent from Claude to Gemini
+ */
+export declare function convertAgent(agentName: string, options?: ConvertOptions, projectDir?: string): ConversionResult;
+/**
+ * Convert all agents from Claude to Gemini
+ */
+export declare function convertAllAgents(options?: ConvertOptions, projectDir?: string): ConversionResult[];