gemkit-cli 0.2.3 → 0.3.0

package/dist/commands/tokens/index.js

@@ -0,0 +1,148 @@
+/**
+ * Tokens command - Session token usage analysis
+ * Matches token_stats.py --latest output format
+ */
+import { getCurrentSessionTokens } from '../../domains/tokens/scanner.js';
+import { calculateCost, formatCost, formatTokens } from '../../domains/tokens/pricing.js';
+import { logger } from '../../services/logger.js';
+import { brand, pc } from '../../utils/colors.js';
+// Box drawing characters
+const BOX = {
+    topLeft: '╭',
+    topRight: '╮',
+    bottomLeft: '╰',
+    bottomRight: '╯',
+    horizontal: '─',
+    vertical: '│',
+    middleLeft: '├',
+    middleRight: '┤',
+};
+function boxTop(width = 75) {
+    return brand.dim(`${BOX.topLeft}${BOX.horizontal.repeat(width - 2)}${BOX.topRight}`);
+}
+function boxBottom(width = 75) {
+    return brand.dim(`${BOX.bottomLeft}${BOX.horizontal.repeat(width - 2)}${BOX.bottomRight}`);
+}
+function boxLine(text, width = 75) {
+    // Strip ANSI codes for length calculation
+    const visibleLen = text.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = Math.max(0, width - 4 - visibleLen);
+    return `${brand.dim(BOX.vertical)} ${text}${' '.repeat(padding)} ${brand.dim(BOX.vertical)}`;
+}
+function sectionHeader(text) {
+    return `\n${pc.bold(brand.geminiPurple(`## ${text}`))}`;
+}
+function padLeft(text, width) {
+    const visibleLen = text.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = Math.max(0, width - visibleLen);
+    return ' '.repeat(padding) + text;
+}
+function padRight(text, width) {
+    const visibleLen = text.replace(/\x1b\[[0-9;]*m/g, '').length;
+    const padding = Math.max(0, width - visibleLen);
+    return text + ' '.repeat(padding);
+}
+function gradientText(text) {
+    // Gradient from Gemini blue (#1a73e8) to purple (#8e24aa)
+    const result = [];
+    const length = text.length;
+    for (let i = 0; i < length; i++) {
+        const ratio = i / Math.max(length - 1, 1);
+        const r = Math.round(26 + (142 - 26) * ratio);
+        const g = Math.round(115 + (36 - 115) * ratio);
+        const b = Math.round(232 + (170 - 232) * ratio);
+        result.push(`\x1b[38;2;${r};${g};${b}m${text[i]}`);
+    }
+    return result.join('') + '\x1b[0m';
+}
+function displaySessionAnalysis(analysis) {
+    const cost = calculateCost(analysis.tokens, analysis.model);
+    // Header box
+    console.log();
+    console.log(boxTop(75));
+    console.log(boxLine(`${gradientText('SESSION ANALYSIS')}  ${brand.dim('Cost:')} ${brand.warn(formatCost(cost.total))}`, 75));
+    console.log(boxBottom(75));
+    // Session info
+    console.log(`\n  ${brand.dim('Session ID:')}   ${brand.accent(analysis.sessionId)}`);
+    console.log(`  ${brand.dim('Start Time:')}   ${analysis.startTime || 'N/A'}`);
+    console.log(`  ${brand.dim('Duration:')}     ${brand.accent(analysis.duration?.formatted || 'N/A')}`);
+    console.log(`  ${brand.dim('Model:')}        ${brand.geminiBlue(analysis.modelsUsed.join(', '))}`);
+    console.log(`  ${brand.dim('Messages:')}     ${brand.accent(String(analysis.messageCount))}`);
+    // Token Breakdown
+    console.log(sectionHeader('Token Breakdown'));
+    console.log(`\n    ${padRight('Category', 10)} ${padLeft('Count', 14)}  ${padLeft('Formatted', 10)}`);
+    console.log(`    ${brand.dim('─'.repeat(10))} ${brand.dim('─'.repeat(14))} ${brand.dim('─'.repeat(10))}`);
+    const tokenKeys = ['input', 'output', 'cached', 'thoughts', 'tool'];
+    for (const key of tokenKeys) {
+        const value = analysis.tokens[key];
+        const countCol = padLeft(brand.accent(value.toLocaleString()), 14);
+        const fmtCol = padLeft(brand.accent(formatTokens(value)), 10);
+        console.log(`    ${padRight(key, 10)} ${countCol}  ${fmtCol}`);
+    }
+    console.log(`    ${brand.dim('─'.repeat(10))} ${brand.dim('─'.repeat(14))} ${brand.dim('─'.repeat(10))}`);
+    const totalCount = padLeft(brand.success(analysis.tokens.total.toLocaleString()), 14);
+    const totalFmt = padLeft(brand.success(formatTokens(analysis.tokens.total)), 10);
+    console.log(`    ${padRight(pc.bold('total'), 10)} ${totalCount}  ${totalFmt}`);
+    // Estimated Cost
+    console.log(sectionHeader('Estimated Cost'));
+    console.log(`\n    ${padRight('Input', 12)} ${padLeft(brand.warn(formatCost(cost.input)), 12)}`);
+    console.log(`    ${padRight('Output', 12)} ${padLeft(brand.warn(formatCost(cost.output)), 12)}`);
+    console.log(`    ${padRight('Cached', 12)} ${padLeft(brand.warn(formatCost(cost.cached)), 12)}`);
+    console.log(`    ${padRight('Thoughts', 12)} ${padLeft(brand.warn(formatCost(cost.thoughts)), 12)}`);
+    console.log(`    ${brand.dim('─'.repeat(24))}`);
+    console.log(`    ${padRight(pc.bold('TOTAL'), 12)} ${padLeft(pc.bold(brand.warn(formatCost(cost.total))), 12)}`);
+    // Averages
+    if (analysis.messageCount > 0) {
+        console.log(sectionHeader('Averages'));
+        const tokensPerMsg = Math.round(analysis.tokens.total / analysis.messageCount);
+        const costPerMsg = cost.total / analysis.messageCount;
+        console.log(`\n    ${brand.dim('Tokens/msg:')}  ${brand.accent(tokensPerMsg.toLocaleString())}`);
+        console.log(`    ${brand.dim('Cost/msg:')}    ${brand.warn(formatCost(costPerMsg))}`);
+    }
+    console.log();
+}
+function displayJsonOutput(analysis) {
+    const cost = calculateCost(analysis.tokens, analysis.model);
+    console.log(JSON.stringify({
+        sessionId: analysis.sessionId,
+        startTime: analysis.startTime,
+        duration: analysis.duration,
+        model: analysis.model,
+        modelsUsed: analysis.modelsUsed,
+        messageCount: analysis.messageCount,
+        tokens: analysis.tokens,
+        averages: analysis.averages,
+        cost: {
+            input: cost.input,
+            output: cost.output,
+            cached: cost.cached,
+            thoughts: cost.thoughts,
+            total: cost.total
+        }
+    }, null, 2));
+}
+export function registerTokensCommand(cli) {
+    cli
+        .command('tokens', 'Show token usage for current session')
+        .alias('t')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const analysis = await getCurrentSessionTokens();
+        if (!analysis) {
+            if (options.json) {
+                console.log(JSON.stringify({ found: false }, null, 2));
+            }
+            else {
+                console.log();
+                logger.info('No token usage found for current session.');
+                console.log();
+            }
+            return;
+        }
+        if (options.json) {
+            displayJsonOutput(analysis);
+            return;
+        }
+        displaySessionAnalysis(analysis);
+    });
+}

package/dist/commands/update/index.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Update command - Update GemKit CLI and/or Kits to latest version
+ *
+ * Two update sources:
+ * 1. CLI (npm): gemkit-cli package from npm registry
+ * 2. Kits (GitHub): .gemini folder from gemkit-kits-starter repo
+ */
+import type { CAC } from 'cac';
+declare const CLI_VERSION: string;
+export declare function registerUpdateCommand(cli: CAC): void;
+/**
+ * Check for updates (used by auto-update checker)
+ */
+export declare function checkForUpdates(): Promise<{
+    cli: {
+        current: string;
+        latest: string;
+        available: boolean;
+    } | null;
+    kits: {
+        current: string;
+        latest: string;
+        available: boolean;
+    } | null;
+}>;
+export { CLI_VERSION };

package/dist/commands/update/index.js

@@ -0,0 +1,199 @@
+/**
+ * Update command - Update GemKit CLI and/or Kits to latest version
+ *
+ * Two update sources:
+ * 1. CLI (npm): gemkit-cli package from npm registry
+ * 2. Kits (GitHub): .gemini folder from gemkit-kits-starter repo
+ */
+import { spawnSync } from 'child_process';
+import { getLatestRelease } from '../../domains/github/releases.js';
+import { downloadRelease } from '../../domains/github/download.js';
+import { extractTarGz } from '../../services/archive.js';
+import { loadMetadata, saveMetadata } from '../../domains/installation/metadata.js';
+import { getLocalGeminiDir } from '../../utils/paths.js';
+import { logger } from '../../services/logger.js';
+import { brand } from '../../utils/colors.js';
+import { getLatestNpmVersion, isUpdateAvailable } from '../../services/npm.js';
+import { readFileSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+// Package name for CLI
+const CLI_PACKAGE_NAME = 'gemkit-cli';
+// Get current CLI version from package.json dynamically
+function getCliVersion() {
+    try {
+        const __filename = fileURLToPath(import.meta.url);
+        const __dirname = dirname(__filename);
+        // Try multiple possible locations for package.json
+        // After esbuild bundling: dist/index.js -> ../package.json
+        // During development: src/commands/update/index.ts -> ../../../package.json
+        const paths = [
+            join(__dirname, '..', 'package.json'), // from dist/ (bundled)
+            join(__dirname, '..', '..', '..', 'package.json'), // from src/commands/update/ (dev)
+        ];
+        for (const pkgPath of paths) {
+            try {
+                const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+                if (pkg.name === CLI_PACKAGE_NAME && pkg.version) {
+                    return pkg.version;
+                }
+            }
+            catch {
+                // Try next path
+            }
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return '0.0.0'; // Fallback
+}
+const CLI_VERSION = getCliVersion();
+export function registerUpdateCommand(cli) {
+    cli
+        .command('update', 'Update GemKit CLI and/or Kits to latest version')
+        .option('-f, --force', 'Force update even if already up to date')
+        .option('--no-backup', 'Disable backup before kits update')
+        .option('--cli', 'Update CLI only (npm package)')
+        .option('--kits', 'Update Kits only (.gemini folder)')
+        .action(async (options) => {
+        // Default: update both if no specific flag
+        const updateCli = options.cli === true || (!options.cli && !options.kits);
+        const updateKits = options.kits === true || (!options.cli && !options.kits);
+        let cliUpdated = false;
+        let kitsUpdated = false;
+        // Update CLI if requested
+        if (updateCli) {
+            cliUpdated = await updateCliPackage(options.force);
+        }
+        // Update Kits if requested
+        if (updateKits) {
+            kitsUpdated = await updateKitsFolder(options.force);
+        }
+        // Summary
+        console.log();
+        if (cliUpdated || kitsUpdated) {
+            logger.success('Update complete!');
+        }
+        else {
+            logger.info('Everything is up to date.');
+        }
+    });
+}
+/**
+ * Update CLI via npm
+ */
+async function updateCliPackage(force) {
+    console.log();
+    logger.info(`${brand.primary('CLI')} Checking for updates...`);
+    const latest = await getLatestNpmVersion(CLI_PACKAGE_NAME);
+    if (!latest) {
+        logger.warn('Failed to check npm registry for CLI updates.');
+        return false;
+    }
+    const currentVersion = CLI_VERSION;
+    const latestVersion = latest.version;
+    if (!isUpdateAvailable(currentVersion, latestVersion) && !force) {
+        logger.success(`CLI is up to date (v${currentVersion})`);
+        return false;
+    }
+    logger.info(`Updating CLI: v${currentVersion} → v${latestVersion}`);
+    // Run npm update
+    const result = spawnSync('npm', ['install', '-g', `${CLI_PACKAGE_NAME}@latest`], {
+        encoding: 'utf-8',
+        stdio: 'inherit',
+        shell: true,
+    });
+    if (result.status !== 0) {
+        logger.error('CLI update failed. Try running manually:');
+        logger.info(`  npm install -g ${CLI_PACKAGE_NAME}@latest`);
+        return false;
+    }
+    logger.success(`CLI updated to v${latestVersion}`);
+    return true;
+}
+/**
+ * Update Kits from GitHub
+ */
+async function updateKitsFolder(force) {
+    console.log();
+    logger.info(`${brand.primary('Kits')} Checking for updates...`);
+    const metadata = loadMetadata();
+    if (!metadata) {
+        logger.warn('GemKit not initialized. Run "gk init" first to install kits.');
+        return false;
+    }
+    const latest = await getLatestRelease();
+    if (!latest) {
+        logger.warn('Failed to check GitHub for kits updates.');
+        return false;
+    }
+    if (latest.version === metadata.version && !force) {
+        logger.success(`Kits are up to date (v${metadata.version})`);
+        return false;
+    }
+    logger.info(`Updating Kits: v${metadata.version} → v${latest.version}`);
+    // Download and extract to temp
+    const tarPath = await downloadRelease(latest);
+    const extractDir = getLocalGeminiDir();
+    const result = await extractTarGz({
+        source: tarPath,
+        destination: extractDir,
+        strip: 1,
+    });
+    if (!result.success) {
+        logger.error(`Kits update failed: ${result.error}`);
+        return false;
+    }
+    // Update metadata
+    const newMetadata = {
+        ...metadata,
+        version: latest.version,
+        installedAt: new Date().toISOString(),
+        installedFiles: result.extractedFiles,
+    };
+    saveMetadata(newMetadata);
+    logger.success(`Kits updated to v${latest.version}`);
+    return true;
+}
+/**
+ * Check for updates (used by auto-update checker)
+ */
+export async function checkForUpdates() {
+    const result = {
+        cli: null,
+        kits: null,
+    };
+    // Check CLI
+    try {
+        const latestCli = await getLatestNpmVersion(CLI_PACKAGE_NAME);
+        if (latestCli) {
+            result.cli = {
+                current: CLI_VERSION,
+                latest: latestCli.version,
+                available: isUpdateAvailable(CLI_VERSION, latestCli.version),
+            };
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    // Check Kits
+    try {
+        const metadata = loadMetadata();
+        const latestKits = await getLatestRelease();
+        if (metadata && latestKits) {
+            result.kits = {
+                current: metadata.version,
+                latest: latestKits.version,
+                available: isUpdateAvailable(metadata.version, latestKits.version),
+            };
+        }
+    }
+    catch {
+        // Ignore errors
+    }
+    return result;
+}
+// Export CLI version for use elsewhere
+export { CLI_VERSION };

package/dist/commands/versions/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Versions command - List available versions
+ */
+import type { CAC } from 'cac';
+export declare function registerVersionsCommand(cli: CAC): void;

package/dist/commands/versions/index.js

@@ -0,0 +1,39 @@
+/**
+ * Versions command - List available versions
+ */
+import { fetchReleases } from '../../domains/github/releases.js';
+import { loadMetadata } from '../../domains/installation/metadata.js';
+import { brand, pc } from '../../utils/colors.js';
+export function registerVersionsCommand(cli) {
+    cli
+        .command('versions', 'List available GemKit versions')
+        .alias('v')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        const metadata = loadMetadata();
+        const releases = await fetchReleases();
+        if (options.json) {
+            console.log(JSON.stringify({
+                current: metadata?.version || null,
+                available: releases
+            }, null, 2));
+            return;
+        }
+        console.log();
+        console.log(pc.bold(brand.geminiPurple('GemKit Versions')));
+        console.log();
+        if (metadata) {
+            console.log(`  ${brand.dim('Current:')}   ${brand.success(metadata.version)}`);
+        }
+        else {
+            console.log(`  ${brand.dim('Current:')}   ${brand.dim('Not installed')}`);
+        }
+        console.log();
+        console.log(`  ${pc.bold('Available Releases:')}`);
+        for (const release of releases) {
+            const marker = release.version === metadata?.version ? brand.success(' (current)') : '';
+            console.log(`  - ${brand.primary(release.version)}${marker}`);
+        }
+        console.log();
+    });
+}

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

@@ -0,0 +1,8 @@
+/**
+ * Agent domain exports
+ * NO spawner, NO routing, NO activity exports
+ */
+export * from './types.js';
+export * from './profile.js';
+export * from './search.js';
+export * from './mappings.js';

package/dist/domains/agent/index.js

@@ -0,0 +1,8 @@
+/**
+ * Agent domain exports
+ * NO spawner, NO routing, NO activity exports
+ */
+export * from './types.js';
+export * from './profile.js';
+export * from './search.js';
+export * from './mappings.js';

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

@@ -0,0 +1,32 @@
+/**
+ * Model and tool mappings between Gemini and Claude CLIs
+ */
+import type { CliProvider } from './types.js';
+/**
+ * Map model to target CLI provider
+ */
+export declare function mapModel(model: string, targetProvider: CliProvider): string;
+/**
+ * Map a single tool to target CLI provider
+ */
+export declare function mapTool(tool: string, targetProvider: CliProvider): string;
+/**
+ * Map array of tools to target CLI provider (deduplicated)
+ */
+export declare function mapTools(tools: string[], targetProvider: CliProvider): string[];
+/**
+ * Get agent directory paths with fallback
+ * Claude: .claude/agents/ -> .gemini/agents/
+ * Gemini: .gemini/agents/ -> .claude/agents/
+ */
+export declare function getAgentPaths(targetProvider: CliProvider): string[];
+/**
+ * Get skills directory paths with fallback
+ * Claude: .claude/skills/ -> .gemini/extensions/
+ * Gemini: .gemini/extensions/ -> .claude/skills/
+ */
+export declare function getSkillPaths(targetProvider: CliProvider): string[];
+/**
+ * Get default model for CLI provider
+ */
+export declare function getDefaultModel(provider: CliProvider): string;

package/dist/domains/agent/mappings.js

@@ -0,0 +1,164 @@
+/**
+ * Model and tool mappings between Gemini and Claude CLIs
+ */
+// ============================================================================
+// MODEL MAPPINGS
+// ============================================================================
+const GEMINI_TO_CLAUDE_MODEL = {
+    'gemini-3-pro-preview': 'opus',
+    'gemini-2.5-pro': 'opus',
+    'gemini-3-flash-preview': 'sonnet',
+    'gemini-2.5-flash': 'sonnet',
+    'gemini-2.5-flash-lite': 'haiku',
+};
+const CLAUDE_TO_GEMINI_MODEL = {
+    'opus': 'gemini-2.5-pro',
+    'sonnet': 'gemini-2.5-flash',
+    'haiku': 'gemini-2.5-flash-lite',
+};
+const CLAUDE_MODELS = ['haiku', 'sonnet', 'opus'];
+/**
+ * Map model to target CLI provider
+ */
+export function mapModel(model, targetProvider) {
+    if (targetProvider === 'claude') {
+        // Check if already a Claude model
+        if (CLAUDE_MODELS.includes(model)) {
+            return model;
+        }
+        return GEMINI_TO_CLAUDE_MODEL[model] || 'sonnet'; // default: sonnet
+    }
+    else {
+        // Check if already a Gemini model
+        if (model.startsWith('gemini-')) {
+            return model;
+        }
+        return CLAUDE_TO_GEMINI_MODEL[model] || 'gemini-2.5-flash'; // default: gemini-2.5-flash
+    }
+}
+// ============================================================================
+// TOOL MAPPINGS
+// ============================================================================
+const GEMINI_TO_CLAUDE_TOOL = {
+    'list_directory': 'Bash',
+    'read_file': 'Read',
+    'write_file': 'Write',
+    'glob': 'Glob',
+    'search_file_content': 'Grep',
+    'replace': 'Edit',
+    'run_shell_command': 'Bash',
+    'web_fetch': 'WebFetch',
+    'google_web_search': 'WebSearch',
+    'save_memory': 'TodoWrite',
+    'write_todos': 'TodoWrite',
+};
+const CLAUDE_TO_GEMINI_TOOL = {
+    'Read': 'read_file',
+    'Write': 'write_file',
+    'Edit': 'replace',
+    'Bash': 'run_shell_command',
+    'Glob': 'glob',
+    'Grep': 'search_file_content',
+    'WebFetch': 'web_fetch',
+    'WebSearch': 'google_web_search',
+    'TodoWrite': 'write_todos',
+    'Task': '', // No direct equivalent
+};
+/**
+ * Check if a tool name is a Claude tool (PascalCase)
+ */
+function isClaudeTool(tool) {
+    return /^[A-Z]/.test(tool);
+}
+/**
+ * Check if a tool name is a Gemini tool (snake_case or starts with gemini)
+ */
+function isGeminiTool(tool) {
+    return tool.includes('_') || tool.startsWith('gemini');
+}
+/**
+ * Map a single tool to target CLI provider
+ */
+export function mapTool(tool, targetProvider) {
+    // Extract base tool and permission suffix
+    // Gemini: run_shell_command(*) -> base: run_shell_command, suffix: (*)
+    // Claude: Bash(git:*) -> base: Bash, suffix: (git:*)
+    const match = tool.match(/^([^(]+)(\(.*\))?$/);
+    const baseTool = match?.[1] || tool;
+    const suffix = match?.[2] || '';
+    if (targetProvider === 'claude') {
+        // Already a Claude tool
+        if (isClaudeTool(baseTool)) {
+            return tool;
+        }
+        const mapped = GEMINI_TO_CLAUDE_TOOL[baseTool];
+        if (!mapped)
+            return tool; // Keep original if no mapping
+        // For Gemini's run_shell_command(*), map to just Bash (Claude handles permissions differently)
+        if (baseTool === 'run_shell_command' && suffix === '(*)') {
+            return mapped; // Just 'Bash', no suffix
+        }
+        return mapped + suffix;
+    }
+    else {
+        // Already a Gemini tool
+        if (isGeminiTool(baseTool)) {
+            return tool;
+        }
+        const mapped = CLAUDE_TO_GEMINI_TOOL[baseTool];
+        if (!mapped)
+            return tool; // Keep original if no mapping
+        // For Claude's Bash, map to run_shell_command(*)
+        if (baseTool === 'Bash' && !suffix) {
+            return 'run_shell_command(*)';
+        }
+        return mapped + suffix;
+    }
+}
+/**
+ * Map array of tools to target CLI provider (deduplicated)
+ */
+export function mapTools(tools, targetProvider) {
+    const mapped = tools
+        .map(t => mapTool(t, targetProvider))
+        .filter(Boolean);
+    return [...new Set(mapped)]; // Deduplicate
+}
+// ============================================================================
+// FOLDER PATHS
+// ============================================================================
+/**
+ * Get agent directory paths with fallback
+ * Claude: .claude/agents/ -> .gemini/agents/
+ * Gemini: .gemini/agents/ -> .claude/agents/
+ */
+export function getAgentPaths(targetProvider) {
+    if (targetProvider === 'claude') {
+        return ['.claude/agents', '.gemini/agents'];
+    }
+    else {
+        return ['.gemini/agents', '.claude/agents'];
+    }
+}
+/**
+ * Get skills directory paths with fallback
+ * Claude: .claude/skills/ -> .gemini/extensions/
+ * Gemini: .gemini/extensions/ -> .claude/skills/
+ */
+export function getSkillPaths(targetProvider) {
+    if (targetProvider === 'claude') {
+        return ['.claude/skills', '.gemini/extensions'];
+    }
+    else {
+        return ['.gemini/extensions', '.claude/skills'];
+    }
+}
+// ============================================================================
+// DEFAULT MODELS
+// ============================================================================
+/**
+ * Get default model for CLI provider
+ */
+export function getDefaultModel(provider) {
+    return provider === 'claude' ? 'sonnet' : 'gemini-2.5-flash';
+}

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

@@ -0,0 +1,26 @@
+/**
+ * Agent profile loading
+ */
+import { AgentProfile, CliProvider } from './types.js';
+/**
+ * Load a single agent profile by name
+ */
+export declare function loadAgentProfile(name: string, projectDir?: string): AgentProfile | null;
+/**
+ * List all available agent profiles
+ */
+export declare function listAgentProfiles(projectDir?: string): AgentProfile[];
+/**
+ * Get agent profile details as formatted string
+ */
+export declare function formatAgentProfile(profile: AgentProfile): string;
+/**
+ * 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 declare function loadAgentProfileWithFallback(name: string, targetProvider: CliProvider, projectDir?: string): AgentProfile | null;
+/**
+ * List all available agent profiles with fallback between providers
+ */
+export declare function listAgentProfilesWithFallback(targetProvider: CliProvider, projectDir?: string): AgentProfile[];