clavix 5.1.0 → 5.2.1

package/README.md

@@ -12,7 +12,8 @@
 
 | Version | Highlights | Details |
 | --- | --- | --- |
-| **v5.0.0** (Latest) | Agentic-first architecture - lean template delivery | [Changelog](CHANGELOG.md#500---2025-01-27) |
+| **v5.2.0** (Latest) | Diagnose command, DRY architecture, feature matrix | [Changelog](CHANGELOG.md) |
+| **v5.0.0** | Agentic-first architecture - lean template delivery | [Changelog](CHANGELOG.md#500---2025-01-27) |
 | **v4.12.0** | Final v4 release with full CLI commands | [Changelog](docs/archive/v4-changelog.md) |
 
 **Requirements:** Node.js >= 18.0.0
@@ -49,6 +50,15 @@ Clavix v5 follows an **agentic-first architecture**:
 | CLI agents | Claude Code, Droid CLI, CodeBuddy CLI, OpenCode, Gemini CLI, Qwen Code, LLXPRT, Amp, Crush CLI, Codex CLI, Augment CLI |
 | Universal adapters | AGENTS.md, GitHub Copilot, OCTO.md, WARP.md |
 
+### Feature Matrix
+
+| Feature | Claude Code | Cursor/Windsurf | Gemini/Qwen | Generic Agents |
+|---------|-------------|-----------------|-------------|----------------|
+| Slash commands | ✅ Native | ✅ Native | ✅ TOML | ❌ Read-only |
+| Doc injection | ✅ CLAUDE.md | ✅ .cursor/rules | ✅ N/A | ✅ AGENTS.md |
+| Namespace dirs | ✅ clavix/ | ✅ clavix/ | ✅ clavix/ | N/A |
+| Auto-detection | ✅ Yes | ✅ Yes | ✅ Yes | N/A |
+
 Full list and configuration: [docs/integrations.md](docs/integrations.md)
 
 ## Quickstart
@@ -77,6 +87,7 @@ The AI agent reads the improve template and:
 
 ### 3. Choose Your Workflow
 
+**Core Workflows:**
 | Command | When to Use |
 |---------|-------------|
 | `/clavix:improve` | Optimize a single prompt (auto-selects depth) |
@@ -84,7 +95,13 @@ The AI agent reads the improve template and:
 | `/clavix:start` | Explore ideas conversationally first |
 | `/clavix:plan` | Generate tasks from a PRD |
 | `/clavix:implement` | Execute tasks with progress tracking |
-| `/clavix:archive` | Archive completed projects |
+| `/clavix:summarize` | Extract requirements from conversation |
+
+**Project Management:**
+| Utility | Purpose |
+|---------|---------|
+| `/clavix:verify` | Check implementation against PRD requirements |
+| `/clavix:archive` | Archive completed projects to `.clavix/archive/` |
 
 See [Choosing the Right Workflow](docs/guides/choosing-workflow.md) for detailed guidance.
 
@@ -96,13 +113,14 @@ clavix update   # After npm update clavix
 
 ## CLI Commands
 
-Clavix v5 has only 4 CLI commands (for setup, not workflows):
+Clavix v5 has 5 CLI commands (for setup and diagnostics, not workflows):
 
 | Command | Purpose |
 |---------|---------|
 | `clavix init` | Initialize Clavix in a project |
 | `clavix update` | Update templates after package update |
 | `clavix config` | Manage configuration |
+| `clavix diagnose` | Check installation and report issues |
 | `clavix version` | Show version |
 
 **All workflows** (`/clavix:improve`, `/clavix:prd`, etc.) are **slash commands** that AI agents execute by reading markdown templates.

package/dist/cli/commands/config.d.ts

@@ -7,9 +7,7 @@ export default class Config extends Command {
         key: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
         value: import("@oclif/core/interfaces").Arg<string | undefined, Record<string, unknown>>;
     };
-    static flags: {
-        global: import("@oclif/core/interfaces").BooleanFlag<boolean>;
-    };
+    static flags: {};
     run(): Promise<void>;
     private showInteractiveMenu;
     private manageIntegrations;

package/dist/cli/commands/config.js

@@ -1,4 +1,4 @@
-import { Command, Args, Flags } from '@oclif/core';
+import { Command, Args } from '@oclif/core';
 import chalk from 'chalk';
 import fs from 'fs-extra';
 import * as path from 'path';
@@ -28,18 +28,9 @@ export default class Config extends Command {
             required: false,
         }),
     };
-    static flags = {
-        global: Flags.boolean({
-            char: 'g',
-            description: 'Use global configuration (not implemented yet)',
-            default: false,
-        }),
-    };
+    static flags = {};
     async run() {
-        const { args, flags } = await this.parse(Config);
-        if (flags.global) {
-            this.warn('Global configuration is not yet supported. Using project configuration.');
-        }
+        const { args } = await this.parse(Config);
         const clavixDir = path.join(process.cwd(), '.clavix');
         const configPath = path.join(clavixDir, 'config.json');
         if (!fs.existsSync(clavixDir) || !fs.existsSync(configPath)) {
@@ -420,7 +411,7 @@ export default class Config extends Command {
     }
     displayConfig(config) {
         this.log(`  ${chalk.gray('Version:')} ${config.version}`);
-        this.log(`  ${chalk.gray('Integrations:')} ${config.integrations.map(p => chalk.cyan(p)).join(', ') || chalk.gray('(none)')}`);
+        this.log(`  ${chalk.gray('Integrations:')} ${config.integrations.map((p) => chalk.cyan(p)).join(', ') || chalk.gray('(none)')}`);
         if (config.preferences) {
             this.log(`\n  ${chalk.bold('Preferences:')}`);
             this.log(`    ${chalk.gray('Auto-open outputs:')} ${config.preferences.autoOpenOutputs ? chalk.green('yes') : chalk.gray('no')}`);

package/dist/cli/commands/diagnose.d.ts

@@ -0,0 +1,15 @@
+import { Command } from '@oclif/core';
+export default class Diagnose extends Command {
+    static description: string;
+    static examples: string[];
+    run(): Promise<void>;
+    private checkVersion;
+    private checkClavixDir;
+    private checkConfig;
+    private static readonly DOC_GENERATORS;
+    private getDocGeneratorFile;
+    private getDocGeneratorName;
+    private checkIntegrations;
+    private checkTemplates;
+}
+//# sourceMappingURL=diagnose.d.ts.map

package/dist/cli/commands/diagnose.js

@@ -0,0 +1,295 @@
+import { Command } from '@oclif/core';
+import chalk from 'chalk';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs-extra';
+import { AgentManager } from '../../core/agent-manager.js';
+import { FileSystem } from '../../utils/file-system.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+export default class Diagnose extends Command {
+    static description = 'Diagnose Clavix installation and configuration';
+    static examples = [
+        '<%= config.bin %> <%= command.id %>',
+        '<%= config.bin %> <%= command.id %> # Check setup and report issues',
+    ];
+    async run() {
+        this.log(chalk.bold.cyan('\n🔍 Clavix Diagnostic Report\n'));
+        const results = [];
+        // 1. Check version
+        results.push(await this.checkVersion());
+        // 2. Check .clavix directory
+        results.push(await this.checkClavixDir());
+        // 3. Check config.json
+        results.push(await this.checkConfig());
+        // 4. Check integrations
+        results.push(...(await this.checkIntegrations()));
+        // 5. Check templates
+        results.push(await this.checkTemplates());
+        // Note: Slash commands are checked per-integration in checkIntegrations()
+        // No separate checkSlashCommands() - commands are in adapter-specific directories
+        // Print results
+        this.log(chalk.gray('─'.repeat(50)));
+        this.log(chalk.bold('\nResults:\n'));
+        let passCount = 0;
+        let warnCount = 0;
+        let failCount = 0;
+        for (const result of results) {
+            const icon = result.status === 'pass'
+                ? chalk.green('✓')
+                : result.status === 'warn'
+                    ? chalk.yellow('⚠')
+                    : chalk.red('✗');
+            const color = result.status === 'pass'
+                ? chalk.green
+                : result.status === 'warn'
+                    ? chalk.yellow
+                    : chalk.red;
+            this.log(`  ${icon} ${color(result.message)}`);
+            if (result.details) {
+                this.log(chalk.gray(`    ${result.details}`));
+            }
+            if (result.status === 'pass')
+                passCount++;
+            else if (result.status === 'warn')
+                warnCount++;
+            else
+                failCount++;
+        }
+        // Summary
+        this.log('\n' + chalk.gray('─'.repeat(50)));
+        this.log(chalk.bold(`\nSummary: ${chalk.green(passCount + ' passed')}, ${chalk.yellow(warnCount + ' warnings')}, ${chalk.red(failCount + ' failed')}\n`));
+        // Recommendations
+        if (failCount > 0) {
+            this.log(chalk.yellow('Recommendations:'));
+            this.log(chalk.gray('  • Run `clavix init` to initialize or repair installation'));
+            this.log(chalk.gray('  • Run `clavix update` to sync templates\n'));
+        }
+        else if (warnCount > 0) {
+            this.log(chalk.cyan('Tip: Run `clavix update` to resolve warnings\n'));
+        }
+        else {
+            this.log(chalk.green('✨ All checks passed! Clavix is ready to use.\n'));
+        }
+    }
+    async checkVersion() {
+        try {
+            const packageJsonPath = path.join(__dirname, '../../../package.json');
+            const packageJson = await fs.readJson(packageJsonPath);
+            return {
+                status: 'pass',
+                message: `Version: v${packageJson.version}`,
+            };
+        }
+        catch {
+            return {
+                status: 'fail',
+                message: 'Could not determine version',
+                details: 'package.json not found',
+            };
+        }
+    }
+    async checkClavixDir() {
+        const clavixDir = path.join(process.cwd(), '.clavix');
+        if (!(await FileSystem.exists(clavixDir))) {
+            return {
+                status: 'fail',
+                message: '.clavix directory not found',
+                details: 'Run `clavix init` to initialize',
+            };
+        }
+        // Check for essential subdirectory (outputs is always created)
+        // Note: 'instructions' is only created when generic integrations are used
+        // Note: 'commands' doesn't exist - commands go to adapter-specific directories
+        const outputsDir = path.join(clavixDir, 'outputs');
+        if (!(await FileSystem.exists(outputsDir))) {
+            return {
+                status: 'warn',
+                message: '.clavix directory incomplete',
+                details: 'Missing: outputs',
+            };
+        }
+        return {
+            status: 'pass',
+            message: '.clavix directory OK',
+        };
+    }
+    async checkConfig() {
+        const configPath = path.join(process.cwd(), '.clavix', 'config.json');
+        if (!(await FileSystem.exists(configPath))) {
+            return {
+                status: 'fail',
+                message: 'config.json not found',
+                details: 'Run `clavix init` to create configuration',
+            };
+        }
+        try {
+            const config = await fs.readJson(configPath);
+            if (!config.version) {
+                return {
+                    status: 'warn',
+                    message: 'config.json missing version field',
+                };
+            }
+            if (!config.integrations || config.integrations.length === 0) {
+                return {
+                    status: 'warn',
+                    message: 'No integrations configured',
+                    details: 'Run `clavix config` to add integrations',
+                };
+            }
+            return {
+                status: 'pass',
+                message: `config.json OK (${config.integrations.length} integration(s))`,
+            };
+        }
+        catch (error) {
+            return {
+                status: 'fail',
+                message: 'config.json is invalid',
+                details: `${error}`,
+            };
+        }
+    }
+    // Doc generators are integrations that generate documentation files, not adapters
+    static DOC_GENERATORS = [
+        'agents-md',
+        'octo-md',
+        'warp-md',
+        'copilot-instructions',
+    ];
+    getDocGeneratorFile(integration) {
+        switch (integration) {
+            case 'agents-md':
+                return 'AGENTS.md';
+            case 'octo-md':
+                return 'OCTO.md';
+            case 'warp-md':
+                return 'WARP.md';
+            case 'copilot-instructions':
+                return path.join('.github', 'copilot-instructions.md');
+            default:
+                return '';
+        }
+    }
+    getDocGeneratorName(integration) {
+        switch (integration) {
+            case 'agents-md':
+                return 'AGENTS.md';
+            case 'octo-md':
+                return 'OCTO.md';
+            case 'warp-md':
+                return 'WARP.md';
+            case 'copilot-instructions':
+                return 'GitHub Copilot';
+            default:
+                return integration;
+        }
+    }
+    async checkIntegrations() {
+        const results = [];
+        const configPath = path.join(process.cwd(), '.clavix', 'config.json');
+        if (!(await FileSystem.exists(configPath))) {
+            return results;
+        }
+        try {
+            const config = await fs.readJson(configPath);
+            const agentManager = new AgentManager();
+            for (const integrationName of config.integrations || []) {
+                // Handle doc generators specially (they don't have adapters)
+                if (Diagnose.DOC_GENERATORS.includes(integrationName)) {
+                    const docFile = this.getDocGeneratorFile(integrationName);
+                    const docPath = path.join(process.cwd(), docFile);
+                    if (await FileSystem.exists(docPath)) {
+                        results.push({
+                            status: 'pass',
+                            message: `${this.getDocGeneratorName(integrationName)}: Generated`,
+                            details: docFile,
+                        });
+                    }
+                    else {
+                        results.push({
+                            status: 'warn',
+                            message: `${this.getDocGeneratorName(integrationName)}: Not generated`,
+                            details: `Run \`clavix update\` to generate`,
+                        });
+                    }
+                    continue;
+                }
+                // Handle adapters (integrations with command generation)
+                const adapter = agentManager.getAdapter(integrationName);
+                if (!adapter) {
+                    results.push({
+                        status: 'warn',
+                        message: `Unknown integration: ${integrationName}`,
+                        details: 'May be removed in a future version',
+                    });
+                    continue;
+                }
+                // Check if adapter's command directory exists
+                const commandPath = adapter.getCommandPath();
+                const commandDirExists = await FileSystem.exists(commandPath);
+                if (commandDirExists) {
+                    const files = await FileSystem.listFiles(commandPath);
+                    const commandCount = files.filter((f) => f.endsWith('.md') || f.endsWith('.toml') || f.endsWith('.mdc')).length;
+                    results.push({
+                        status: 'pass',
+                        message: `${adapter.displayName}: ${commandCount} command(s)`,
+                        details: commandPath,
+                    });
+                }
+                else {
+                    results.push({
+                        status: 'warn',
+                        message: `${adapter.displayName}: commands not generated`,
+                        details: `Run \`clavix update\` to generate`,
+                    });
+                }
+            }
+        }
+        catch {
+            // Config read error handled elsewhere
+        }
+        return results;
+    }
+    async checkTemplates() {
+        const templateDir = path.join(__dirname, '../../templates');
+        if (!(await FileSystem.exists(templateDir))) {
+            return {
+                status: 'fail',
+                message: 'Template directory not found',
+                details: 'Package may be corrupted',
+            };
+        }
+        // Check for canonical templates
+        const canonicalDir = path.join(templateDir, 'slash-commands', '_canonical');
+        if (!(await FileSystem.exists(canonicalDir))) {
+            return {
+                status: 'warn',
+                message: 'Canonical templates missing',
+                details: 'Try reinstalling clavix',
+            };
+        }
+        const requiredTemplates = ['improve.md', 'prd.md', 'plan.md', 'implement.md'];
+        const missing = [];
+        for (const template of requiredTemplates) {
+            const templatePath = path.join(canonicalDir, template);
+            if (!(await FileSystem.exists(templatePath))) {
+                missing.push(template);
+            }
+        }
+        if (missing.length > 0) {
+            return {
+                status: 'warn',
+                message: 'Some canonical templates missing',
+                details: missing.join(', '),
+            };
+        }
+        return {
+            status: 'pass',
+            message: 'Package templates OK',
+        };
+    }
+}
+//# sourceMappingURL=diagnose.js.map

package/dist/core/adapters/agents-md-generator.d.ts

@@ -4,20 +4,10 @@
  */
 export declare class AgentsMdGenerator {
     static readonly TARGET_FILE = "AGENTS.md";
-    static readonly START_MARKER = "<!-- CLAVIX:START -->";
-    static readonly END_MARKER = "<!-- CLAVIX:END -->";
     /**
      * Generate or update AGENTS.md with Clavix workflows
      */
     static generate(): Promise<void>;
-    /**
-     * Inject or update managed block in AGENTS.md
-     */
-    private static injectManagedBlock;
-    /**
-     * Escape special regex characters
-     */
-    private static escapeRegex;
     /**
      * Check if AGENTS.md has Clavix block
      */

package/dist/core/adapters/agents-md-generator.js

@@ -1,7 +1,8 @@
-import { FileSystem } from '../../utils/file-system.js';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { FileSystem } from '../../utils/file-system.js';
+import { DocInjector } from '../doc-injector.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -10,60 +11,25 @@ const __dirname = dirname(__filename);
  */
 export class AgentsMdGenerator {
     static TARGET_FILE = 'AGENTS.md';
-    static START_MARKER = '<!-- CLAVIX:START -->';
-    static END_MARKER = '<!-- CLAVIX:END -->';
     /**
      * Generate or update AGENTS.md with Clavix workflows
      */
     static async generate() {
         const templatePath = path.join(__dirname, '../../templates/agents/agents.md');
-        // Check if template exists
         if (!(await FileSystem.exists(templatePath))) {
             throw new Error(`AGENTS.md template not found at ${templatePath}`);
         }
         const template = await FileSystem.readFile(templatePath);
-        // Inject into AGENTS.md using managed blocks
-        await this.injectManagedBlock(this.TARGET_FILE, template);
-    }
-    /**
-     * Inject or update managed block in AGENTS.md
-     */
-    static async injectManagedBlock(filePath, content) {
-        let fileContent = '';
-        // Read existing file or start with empty content
-        if (await FileSystem.exists(filePath)) {
-            fileContent = await FileSystem.readFile(filePath);
-        }
-        const blockRegex = new RegExp(`${this.escapeRegex(this.START_MARKER)}[\\s\\S]*?${this.escapeRegex(this.END_MARKER)}`, 'g');
-        const wrappedContent = `${this.START_MARKER}\n${content}\n${this.END_MARKER}`;
-        if (blockRegex.test(fileContent)) {
-            // Replace existing block
-            fileContent = fileContent.replace(blockRegex, wrappedContent);
-        }
-        else {
-            // Append new block
-            if (fileContent && !fileContent.endsWith('\n\n')) {
-                fileContent += '\n\n';
-            }
-            fileContent += wrappedContent + '\n';
-        }
-        await FileSystem.writeFileAtomic(filePath, fileContent);
-    }
-    /**
-     * Escape special regex characters
-     */
-    static escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        await DocInjector.injectBlock(this.TARGET_FILE, template, {
+            createIfMissing: true,
+            validateMarkdown: false, // Template is pre-validated
+        });
     }
     /**
      * Check if AGENTS.md has Clavix block
      */
     static async hasClavixBlock() {
-        if (!(await FileSystem.exists(this.TARGET_FILE))) {
-            return false;
-        }
-        const content = await FileSystem.readFile(this.TARGET_FILE);
-        return content.includes(this.START_MARKER);
+        return DocInjector.hasBlock(this.TARGET_FILE);
     }
 }
 //# sourceMappingURL=agents-md-generator.js.map

package/dist/core/adapters/copilot-instructions-generator.d.ts

@@ -4,20 +4,10 @@
  */
 export declare class CopilotInstructionsGenerator {
     static readonly TARGET_FILE = ".github/copilot-instructions.md";
-    static readonly START_MARKER = "<!-- CLAVIX:START -->";
-    static readonly END_MARKER = "<!-- CLAVIX:END -->";
     /**
      * Generate or update .github/copilot-instructions.md with Clavix workflows
      */
     static generate(): Promise<void>;
-    /**
-     * Inject or update managed block in .github/copilot-instructions.md
-     */
-    private static injectManagedBlock;
-    /**
-     * Escape special regex characters
-     */
-    private static escapeRegex;
     /**
      * Check if .github/copilot-instructions.md has Clavix block
      */

package/dist/core/adapters/copilot-instructions-generator.js

@@ -1,7 +1,8 @@
-import { FileSystem } from '../../utils/file-system.js';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
+import { FileSystem } from '../../utils/file-system.js';
+import { DocInjector } from '../doc-injector.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 /**
@@ -10,62 +11,27 @@ const __dirname = dirname(__filename);
  */
 export class CopilotInstructionsGenerator {
     static TARGET_FILE = '.github/copilot-instructions.md';
-    static START_MARKER = '<!-- CLAVIX:START -->';
-    static END_MARKER = '<!-- CLAVIX:END -->';
     /**
      * Generate or update .github/copilot-instructions.md with Clavix workflows
      */
     static async generate() {
         const templatePath = path.join(__dirname, '../../templates/agents/copilot-instructions.md');
-        // Check if template exists
         if (!(await FileSystem.exists(templatePath))) {
             throw new Error(`Copilot instructions template not found at ${templatePath}`);
         }
         const template = await FileSystem.readFile(templatePath);
         // Ensure .github directory exists
         await FileSystem.ensureDir('.github');
-        // Inject into .github/copilot-instructions.md using managed blocks
-        await this.injectManagedBlock(this.TARGET_FILE, template);
-    }
-    /**
-     * Inject or update managed block in .github/copilot-instructions.md
-     */
-    static async injectManagedBlock(filePath, content) {
-        let fileContent = '';
-        // Read existing file or start with empty content
-        if (await FileSystem.exists(filePath)) {
-            fileContent = await FileSystem.readFile(filePath);
-        }
-        const blockRegex = new RegExp(`${this.escapeRegex(this.START_MARKER)}[\\s\\S]*?${this.escapeRegex(this.END_MARKER)}`, 'g');
-        const wrappedContent = `${this.START_MARKER}\n${content}\n${this.END_MARKER}`;
-        if (blockRegex.test(fileContent)) {
-            // Replace existing block
-            fileContent = fileContent.replace(blockRegex, wrappedContent);
-        }
-        else {
-            // Append new block
-            if (fileContent && !fileContent.endsWith('\n\n')) {
-                fileContent += '\n\n';
-            }
-            fileContent += wrappedContent + '\n';
-        }
-        await FileSystem.writeFileAtomic(filePath, fileContent);
-    }
-    /**
-     * Escape special regex characters
-     */
-    static escapeRegex(str) {
-        return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+        await DocInjector.injectBlock(this.TARGET_FILE, template, {
+            createIfMissing: true,
+            validateMarkdown: false,
+        });
     }
     /**
      * Check if .github/copilot-instructions.md has Clavix block
      */
     static async hasClavixBlock() {
-        if (!(await FileSystem.exists(this.TARGET_FILE))) {
-            return false;
-        }
-        const content = await FileSystem.readFile(this.TARGET_FILE);
-        return content.includes(this.START_MARKER);
+        return DocInjector.hasBlock(this.TARGET_FILE);
     }
 }
 //# sourceMappingURL=copilot-instructions-generator.js.map

package/dist/core/adapters/gemini-adapter.d.ts

@@ -1,27 +1,11 @@
-import { BaseAdapter } from './base-adapter.js';
-import { CommandTemplate } from '../../types/agent.js';
+import { TomlFormattingAdapter } from './toml-formatting-adapter.js';
 /**
  * Gemini CLI adapter
  * Commands stored as TOML files under .gemini/commands/clavix by default
  */
-export declare class GeminiAdapter extends BaseAdapter {
-    private readonly options;
-    readonly name = "gemini";
-    readonly displayName = "Gemini CLI";
-    readonly fileExtension = ".toml";
-    readonly features: {
-        supportsSubdirectories: boolean;
-        supportsFrontmatter: boolean;
-        argumentPlaceholder: string;
-    };
+export declare class GeminiAdapter extends TomlFormattingAdapter {
     constructor(options?: {
         useNamespace?: boolean;
     });
-    get directory(): string;
-    detectProject(): Promise<boolean>;
-    getCommandPath(): string;
-    getTargetFilename(name: string): string;
-    protected formatCommand(template: CommandTemplate): string;
-    private getHomeDir;
 }
 //# sourceMappingURL=gemini-adapter.d.ts.map