gemkit-cli 0.2.3 → 0.3.1

package/dist/domains/convert/converter.js

@@ -0,0 +1,471 @@
+/**
+ * Skill to Extension Converter
+ * Converts .claude/skills to .gemini/extensions
+ */
+import { existsSync, readFileSync, readdirSync, mkdirSync, writeFileSync, copyFileSync, statSync } from 'fs';
+import { join } from 'path';
+import { MODEL_MAPPING } from './types.js';
+// Default paths
+const CLAUDE_SKILLS_DIR = '.claude/skills';
+const GEMINI_EXTENSIONS_DIR = '.gemini/extensions';
+const CLAUDE_AGENTS_DIR = '.claude/agents';
+const GEMINI_AGENTS_DIR = '.gemini/agents';
+/**
+ * Parse YAML-like frontmatter from markdown file
+ */
+export function parseFrontmatter(content) {
+    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+    if (!match)
+        return null;
+    const frontmatter = { name: '', description: '' };
+    const lines = match[1].split(/\r?\n/);
+    for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1)
+            continue;
+        const key = line.slice(0, colonIndex).trim();
+        let value = line.slice(colonIndex + 1).trim();
+        // Remove quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        frontmatter[key] = value;
+    }
+    return frontmatter;
+}
+/**
+ * Get skills directory path
+ */
+export function getSkillsDir(projectDir = process.cwd()) {
+    return join(projectDir, CLAUDE_SKILLS_DIR);
+}
+/**
+ * Get extensions directory path
+ */
+export function getExtensionsDir(projectDir = process.cwd()) {
+    return join(projectDir, GEMINI_EXTENSIONS_DIR);
+}
+/**
+ * List all available Claude skills
+ */
+export function listSkills(projectDir = process.cwd()) {
+    const skillsDir = getSkillsDir(projectDir);
+    if (!existsSync(skillsDir)) {
+        return [];
+    }
+    const skills = [];
+    try {
+        const dirs = readdirSync(skillsDir, { withFileTypes: true })
+            .filter(d => d.isDirectory())
+            .map(d => d.name);
+        for (const name of dirs) {
+            const skillPath = join(skillsDir, name);
+            const skillMdPath = join(skillPath, 'SKILL.md');
+            const referencesPath = join(skillPath, 'references');
+            const hasSkillMd = existsSync(skillMdPath);
+            const hasReferences = existsSync(referencesPath) && statSync(referencesPath).isDirectory();
+            let description;
+            if (hasSkillMd) {
+                try {
+                    const content = readFileSync(skillMdPath, 'utf-8');
+                    const frontmatter = parseFrontmatter(content);
+                    description = frontmatter?.description;
+                }
+                catch {
+                    // Ignore parse errors
+                }
+            }
+            skills.push({
+                name,
+                path: skillPath,
+                hasSkillMd,
+                hasReferences,
+                description
+            });
+        }
+    }
+    catch {
+        // Return empty on error
+    }
+    return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Check if an extension already exists
+ */
+export function extensionExists(name, projectDir = process.cwd()) {
+    const extPath = join(getExtensionsDir(projectDir), name);
+    return existsSync(extPath);
+}
+/**
+ * Generate gemini-extension.json content
+ */
+export function generateExtensionJson(frontmatter, hasReferences) {
+    const contextFileName = ['SKILL.md'];
+    if (hasReferences) {
+        contextFileName.push('references/*.md');
+    }
+    return {
+        name: frontmatter.name || '',
+        version: '1.0.0',
+        description: frontmatter.description || '',
+        license: 'MIT',
+        contextFileName
+    };
+}
+/**
+ * Copy directory recursively
+ */
+function copyDirRecursive(src, dest, created) {
+    if (!existsSync(dest)) {
+        mkdirSync(dest, { recursive: true });
+        created.push(dest);
+    }
+    const entries = readdirSync(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = join(src, entry.name);
+        const destPath = join(dest, entry.name);
+        if (entry.isDirectory()) {
+            copyDirRecursive(srcPath, destPath, created);
+        }
+        else {
+            copyFileSync(srcPath, destPath);
+            created.push(destPath);
+        }
+    }
+}
+/**
+ * Convert a single skill to extension
+ */
+export function convertSkill(skillName, options = {}, projectDir = process.cwd()) {
+    const result = {
+        skill: skillName,
+        success: false,
+        created: [],
+        skipped: [],
+        errors: []
+    };
+    const skillsDir = getSkillsDir(projectDir);
+    const extensionsDir = getExtensionsDir(projectDir);
+    const skillPath = join(skillsDir, skillName);
+    const extPath = join(extensionsDir, skillName);
+    // Check if skill exists
+    if (!existsSync(skillPath)) {
+        result.errors.push(`Skill not found: ${skillName}`);
+        return result;
+    }
+    // Check if SKILL.md exists
+    const skillMdPath = join(skillPath, 'SKILL.md');
+    if (!existsSync(skillMdPath)) {
+        result.errors.push(`SKILL.md not found in ${skillName}`);
+        return result;
+    }
+    // Check if extension already exists
+    if (extensionExists(skillName, projectDir) && !options.force) {
+        result.skipped.push(`Extension already exists: ${skillName} (use --force to overwrite)`);
+        return result;
+    }
+    // Parse frontmatter
+    let frontmatter = null;
+    try {
+        const content = readFileSync(skillMdPath, 'utf-8');
+        frontmatter = parseFrontmatter(content);
+    }
+    catch (e) {
+        result.errors.push(`Failed to read SKILL.md: ${e instanceof Error ? e.message : String(e)}`);
+        return result;
+    }
+    if (!frontmatter || !frontmatter.name) {
+        // Try to use directory name if no frontmatter
+        frontmatter = {
+            name: skillName,
+            description: ''
+        };
+    }
+    // Check for references
+    const referencesPath = join(skillPath, 'references');
+    const hasReferences = existsSync(referencesPath) && statSync(referencesPath).isDirectory();
+    // Generate extension JSON
+    const extensionJson = generateExtensionJson(frontmatter, hasReferences);
+    if (options.dryRun) {
+        result.created.push(`[DRY RUN] Would create: ${extPath}`);
+        result.created.push(`[DRY RUN] Would create: ${join(extPath, 'gemini-extension.json')}`);
+        result.created.push(`[DRY RUN] Would copy: SKILL.md`);
+        if (hasReferences) {
+            result.created.push(`[DRY RUN] Would copy: references/`);
+        }
+        result.success = true;
+        return result;
+    }
+    try {
+        // Create extension directory
+        if (!existsSync(extPath)) {
+            mkdirSync(extPath, { recursive: true });
+            result.created.push(extPath);
+        }
+        // Write gemini-extension.json
+        const jsonPath = join(extPath, 'gemini-extension.json');
+        writeFileSync(jsonPath, JSON.stringify(extensionJson, null, 2) + '\n');
+        result.created.push(jsonPath);
+        // Copy SKILL.md
+        const destSkillMd = join(extPath, 'SKILL.md');
+        copyFileSync(skillMdPath, destSkillMd);
+        result.created.push(destSkillMd);
+        // Copy references if exists
+        if (hasReferences) {
+            const destReferences = join(extPath, 'references');
+            copyDirRecursive(referencesPath, destReferences, result.created);
+        }
+        // Copy any other files (assets, scripts, etc.)
+        const entries = readdirSync(skillPath, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.name === 'SKILL.md' || entry.name === 'references')
+                continue;
+            const srcPath = join(skillPath, entry.name);
+            const destPath = join(extPath, entry.name);
+            if (entry.isDirectory()) {
+                copyDirRecursive(srcPath, destPath, result.created);
+            }
+            else {
+                copyFileSync(srcPath, destPath);
+                result.created.push(destPath);
+            }
+        }
+        result.success = true;
+    }
+    catch (e) {
+        result.errors.push(`Failed to convert: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return result;
+}
+/**
+ * Convert all skills to extensions
+ */
+export function convertAllSkills(options = {}, projectDir = process.cwd()) {
+    const skills = listSkills(projectDir);
+    const results = [];
+    for (const skill of skills) {
+        const result = convertSkill(skill.name, options, projectDir);
+        results.push(result);
+    }
+    return results;
+}
+/**
+ * Get conversion summary
+ */
+export function getConversionSummary(results) {
+    return {
+        total: results.length,
+        success: results.filter(r => r.success && r.errors.length === 0 && r.skipped.length === 0).length,
+        skipped: results.filter(r => r.skipped.length > 0).length,
+        failed: results.filter(r => r.errors.length > 0).length
+    };
+}
+// ═══════════════════════════════════════════════════════════════════════════
+// AGENT CONVERSION
+// ═══════════════════════════════════════════════════════════════════════════
+/**
+ * Get Claude agents directory path
+ */
+export function getClaudeAgentsDir(projectDir = process.cwd()) {
+    return join(projectDir, CLAUDE_AGENTS_DIR);
+}
+/**
+ * Get Gemini agents directory path
+ */
+export function getGeminiAgentsDir(projectDir = process.cwd()) {
+    return join(projectDir, GEMINI_AGENTS_DIR);
+}
+/**
+ * Parse agent frontmatter
+ */
+export function parseAgentFrontmatter(content) {
+    const frontmatter = parseFrontmatter(content);
+    if (!frontmatter)
+        return null;
+    return {
+        name: frontmatter.name || '',
+        description: frontmatter.description || '',
+        model: frontmatter.model,
+        skills: frontmatter.skills
+    };
+}
+/**
+ * List all available Claude agents
+ */
+export function listAgents(projectDir = process.cwd()) {
+    const agentsDir = getClaudeAgentsDir(projectDir);
+    if (!existsSync(agentsDir)) {
+        return [];
+    }
+    const agents = [];
+    try {
+        const files = readdirSync(agentsDir, { withFileTypes: true })
+            .filter(f => f.isFile() && f.name.endsWith('.md'))
+            .map(f => f.name);
+        for (const file of files) {
+            const filePath = join(agentsDir, file);
+            const name = file.replace(/\.md$/, '');
+            let description;
+            let model;
+            let skills;
+            try {
+                const content = readFileSync(filePath, 'utf-8');
+                const frontmatter = parseAgentFrontmatter(content);
+                if (frontmatter) {
+                    description = frontmatter.description;
+                    model = frontmatter.model;
+                    skills = frontmatter.skills;
+                }
+            }
+            catch {
+                // Ignore parse errors
+            }
+            agents.push({
+                name,
+                path: filePath,
+                description,
+                model,
+                skills
+            });
+        }
+    }
+    catch {
+        // Return empty on error
+    }
+    return agents.sort((a, b) => a.name.localeCompare(b.name));
+}
+/**
+ * Check if an agent already exists in Gemini
+ */
+export function geminiAgentExists(name, projectDir = process.cwd()) {
+    const agentPath = join(getGeminiAgentsDir(projectDir), `${name}.md`);
+    return existsSync(agentPath);
+}
+/**
+ * Map Claude model to Gemini model
+ */
+export function mapModel(model) {
+    if (!model)
+        return undefined;
+    return MODEL_MAPPING[model] || model;
+}
+/**
+ * Update frontmatter in markdown content
+ */
+function updateFrontmatter(content, updates) {
+    const match = content.match(/^(---\r?\n)([\s\S]*?)(\r?\n---)/);
+    if (!match)
+        return content;
+    const [fullMatch, startDelim, frontmatterContent, endDelim] = match;
+    const lines = frontmatterContent.split(/\r?\n/);
+    const newLines = [];
+    const processedKeys = new Set();
+    for (const line of lines) {
+        const colonIndex = line.indexOf(':');
+        if (colonIndex === -1) {
+            newLines.push(line);
+            continue;
+        }
+        const key = line.slice(0, colonIndex).trim();
+        if (key in updates) {
+            processedKeys.add(key);
+            if (updates[key] !== undefined) {
+                newLines.push(`${key}: ${updates[key]}`);
+            }
+            // If undefined, skip the line (remove the field)
+        }
+        else {
+            newLines.push(line);
+        }
+    }
+    // Add any new keys that weren't in the original
+    for (const [key, value] of Object.entries(updates)) {
+        if (!processedKeys.has(key) && value !== undefined) {
+            newLines.push(`${key}: ${value}`);
+        }
+    }
+    const newFrontmatter = startDelim + newLines.join('\n') + endDelim;
+    return content.replace(fullMatch, newFrontmatter);
+}
+/**
+ * Convert a single agent from Claude to Gemini
+ */
+export function convertAgent(agentName, options = {}, projectDir = process.cwd()) {
+    const result = {
+        skill: agentName, // Reusing skill field for agent name
+        success: false,
+        created: [],
+        skipped: [],
+        errors: []
+    };
+    const claudeAgentsDir = getClaudeAgentsDir(projectDir);
+    const geminiAgentsDir = getGeminiAgentsDir(projectDir);
+    const srcPath = join(claudeAgentsDir, `${agentName}.md`);
+    const destPath = join(geminiAgentsDir, `${agentName}.md`);
+    // Check if source agent exists
+    if (!existsSync(srcPath)) {
+        result.errors.push(`Agent not found: ${agentName}`);
+        return result;
+    }
+    // Check if destination already exists
+    if (geminiAgentExists(agentName, projectDir) && !options.force) {
+        result.skipped.push(`Agent already exists in .gemini/agents: ${agentName} (use --force to overwrite)`);
+        return result;
+    }
+    // Read source content
+    let content;
+    try {
+        content = readFileSync(srcPath, 'utf-8');
+    }
+    catch (e) {
+        result.errors.push(`Failed to read agent file: ${e instanceof Error ? e.message : String(e)}`);
+        return result;
+    }
+    // Parse frontmatter to get model
+    const frontmatter = parseAgentFrontmatter(content);
+    const originalModel = frontmatter?.model;
+    const mappedModel = mapModel(originalModel);
+    // Update model if mapping exists and is different
+    let finalContent = content;
+    if (originalModel && mappedModel && originalModel !== mappedModel) {
+        finalContent = updateFrontmatter(content, { model: mappedModel });
+    }
+    if (options.dryRun) {
+        result.created.push(`[DRY RUN] Would create: ${destPath}`);
+        if (originalModel && mappedModel && originalModel !== mappedModel) {
+            result.created.push(`[DRY RUN] Would map model: ${originalModel} -> ${mappedModel}`);
+        }
+        result.success = true;
+        return result;
+    }
+    try {
+        // Ensure destination directory exists
+        if (!existsSync(geminiAgentsDir)) {
+            mkdirSync(geminiAgentsDir, { recursive: true });
+        }
+        // Write converted agent
+        writeFileSync(destPath, finalContent);
+        result.created.push(destPath);
+        if (originalModel && mappedModel && originalModel !== mappedModel) {
+            result.created.push(`Model mapped: ${originalModel} -> ${mappedModel}`);
+        }
+        result.success = true;
+    }
+    catch (e) {
+        result.errors.push(`Failed to convert: ${e instanceof Error ? e.message : String(e)}`);
+    }
+    return result;
+}
+/**
+ * Convert all agents from Claude to Gemini
+ */
+export function convertAllAgents(options = {}, projectDir = process.cwd()) {
+    const agents = listAgents(projectDir);
+    const results = [];
+    for (const agent of agents) {
+        const result = convertAgent(agent.name, options, projectDir);
+        results.push(result);
+    }
+    return results;
+}

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

@@ -0,0 +1,5 @@
+/**
+ * Convert domain exports
+ */
+export * from './types.js';
+export * from './converter.js';

package/dist/domains/convert/index.js

@@ -0,0 +1,5 @@
+/**
+ * Convert domain exports
+ */
+export * from './types.js';
+export * from './converter.js';

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

@@ -0,0 +1,88 @@
+/**
+ * Types for skill/extension conversion
+ */
+/**
+ * Claude skill frontmatter
+ */
+export interface SkillFrontmatter {
+    name: string;
+    description: string;
+    [key: string]: unknown;
+}
+/**
+ * Gemini extension configuration
+ */
+export interface GeminiExtension {
+    name: string;
+    version: string;
+    description: string;
+    license: string;
+    contextFileName: string[];
+    author?: string;
+    tools?: GeminiTool[];
+}
+/**
+ * Gemini extension tool definition
+ */
+export interface GeminiTool {
+    name: string;
+    description: string;
+    command: string;
+    inputSchema: {
+        type: string;
+        properties: Record<string, unknown>;
+        required?: string[];
+    };
+}
+/**
+ * Skill info for listing
+ */
+export interface SkillInfo {
+    name: string;
+    path: string;
+    hasSkillMd: boolean;
+    hasReferences: boolean;
+    description?: string;
+}
+/**
+ * Conversion result
+ */
+export interface ConversionResult {
+    skill: string;
+    success: boolean;
+    created: string[];
+    skipped: string[];
+    errors: string[];
+}
+/**
+ * Conversion options
+ */
+export interface ConvertOptions {
+    force?: boolean;
+    dryRun?: boolean;
+    verbose?: boolean;
+}
+/**
+ * Agent frontmatter
+ */
+export interface AgentFrontmatter {
+    name: string;
+    description: string;
+    model?: string;
+    skills?: string;
+    [key: string]: unknown;
+}
+/**
+ * Agent info for listing
+ */
+export interface AgentInfo {
+    name: string;
+    path: string;
+    description?: string;
+    model?: string;
+    skills?: string;
+}
+/**
+ * Model mapping for conversion (Claude -> Gemini)
+ */
+export declare const MODEL_MAPPING: Record<string, string>;

package/dist/domains/convert/types.js

@@ -0,0 +1,18 @@
+/**
+ * Types for skill/extension conversion
+ */
+/**
+ * Model mapping for conversion (Claude -> Gemini)
+ */
+export const MODEL_MAPPING = {
+    // Claude models to Gemini equivalents
+    'claude-3-opus': 'gemini-2.5-pro',
+    'claude-3-sonnet': 'gemini-2.5-flash',
+    'claude-3-haiku': 'gemini-2.5-flash',
+    'claude-3.5-sonnet': 'gemini-2.5-pro',
+    'claude-3.5-haiku': 'gemini-2.5-flash',
+    // Keep Gemini models as-is
+    'gemini-2.5-pro': 'gemini-2.5-pro',
+    'gemini-2.5-flash': 'gemini-2.5-flash',
+    'gemini-3-flash-preview': 'gemini-3-flash-preview',
+};

package/dist/domains/github/download.d.ts

@@ -0,0 +1,12 @@
+/**
+ * GitHub download utilities
+ */
+import type { Release, ReleaseAsset } from '../../types/index.js';
+/**
+ * Download release asset
+ */
+export declare function downloadAsset(asset: ReleaseAsset, destDir?: string): Promise<string>;
+/**
+ * Download release tarball
+ */
+export declare function downloadRelease(release: Release): Promise<string>;

package/dist/domains/github/download.js

@@ -0,0 +1,51 @@
+/**
+ * GitHub download utilities
+ */
+import { createWriteStream, existsSync, mkdirSync } from 'fs';
+import { pipeline } from 'stream/promises';
+import { join } from 'path';
+import { GEMKIT_CACHE_DIR } from '../../utils/paths.js';
+import { GitHubError } from '../../utils/errors.js';
+/**
+ * Download release asset
+ */
+export async function downloadAsset(asset, destDir = GEMKIT_CACHE_DIR) {
+    if (!existsSync(destDir)) {
+        mkdirSync(destDir, { recursive: true });
+    }
+    const destPath = join(destDir, asset.name);
+    try {
+        const response = await fetch(asset.downloadUrl, {
+            headers: {
+                'User-Agent': 'gemkit-cli',
+            },
+        });
+        if (!response.ok) {
+            throw new GitHubError(`Failed to download asset: ${response.status}`);
+        }
+        if (!response.body) {
+            throw new GitHubError('No response body');
+        }
+        const fileStream = createWriteStream(destPath);
+        // @ts-ignore - Node.js stream compatibility
+        await pipeline(response.body, fileStream);
+        return destPath;
+    }
+    catch (error) {
+        if (error instanceof GitHubError) {
+            throw error;
+        }
+        throw new GitHubError(`Download failed: ${error}`);
+    }
+}
+/**
+ * Download release tarball
+ */
+export async function downloadRelease(release) {
+    // Find tarball asset
+    const tarball = release.assets.find(a => a.name.endsWith('.tar.gz') || a.name.endsWith('.tgz'));
+    if (!tarball) {
+        throw new GitHubError('No tarball asset found in release');
+    }
+    return downloadAsset(tarball);
+}

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

@@ -0,0 +1,2 @@
+export * from './releases.js';
+export * from './download.js';

package/dist/domains/github/index.js

@@ -0,0 +1,2 @@
+export * from './releases.js';
+export * from './download.js';

package/dist/domains/github/releases.d.ts

@@ -0,0 +1,16 @@
+/**
+ * GitHub releases API - Public repos only, no auth
+ */
+import type { Release } from '../../types/index.js';
+/**
+ * Fetch releases from GitHub
+ */
+export declare function fetchReleases(limit?: number): Promise<Release[]>;
+/**
+ * Get latest release
+ */
+export declare function getLatestRelease(): Promise<Release | null>;
+/**
+ * Get release by version
+ */
+export declare function getReleaseByVersion(version: string): Promise<Release | null>;