vibeman 0.0.0 → 0.0.2

package/dist/runtime/api/lib/markdown-utils.test.js

@@ -0,0 +1,348 @@
+import { describe, it, expect } from 'vitest';
+import { markdownToHtml, htmlToMarkdown } from './markdown-utils.js';
+describe('markdown-utils', () => {
+    describe('markdownToHtml', () => {
+        it('should return empty string for empty input', () => {
+            expect(markdownToHtml('')).toBe('');
+            expect(markdownToHtml('  ')).toBe('');
+            expect(markdownToHtml(null)).toBe('');
+            expect(markdownToHtml(undefined)).toBe('');
+        });
+        it('should convert task item to HTML', () => {
+            const markdown = `- [ ] Task item
+- [x] Checked task`;
+            const html = markdownToHtml(markdown);
+            // Check for proper TipTap TaskList structure
+            expect(html).toContain('data-type="taskList"');
+            expect(html).toContain('data-type="taskItem"');
+            expect(html).toContain('data-checked="false"');
+            expect(html).toContain('data-checked="true"');
+            expect(html).toContain('<label contenteditable="false">');
+            expect(html).toContain('<input type="checkbox" >');
+            expect(html).toContain('<input type="checkbox" checked>');
+            expect(html).toContain('<p>Task item</p>');
+            expect(html).toContain('<p>Checked task</p>');
+        });
+        it('should convert basic markdown to HTML', () => {
+            const markdown = '# Heading 1\n\nThis is a paragraph.\n\n**Bold text** and *italic text*.';
+            const html = markdownToHtml(markdown);
+            expect(html).toContain('<h1>Heading 1</h1>');
+            expect(html).toContain('<p>This is a paragraph.</p>');
+            expect(html).toContain('<strong>Bold text</strong>');
+            expect(html).toContain('<em>italic text</em>');
+        });
+        //     it('should convert simple task lists to HTML with data-type attribute', () => {
+        //       const markdown = '- [ ] Unchecked task\n- [x] Checked task';
+        //       const html = markdownToHtml(markdown);
+        //       expect(html).toContain('data-type="taskItem"');
+        //       expect(html).toContain('<input type="checkbox" disabled>');
+        //       expect(html).toContain('<input type="checkbox" checked disabled>');
+        //       expect(html).toContain('Unchecked task');
+        //       expect(html).toContain('Checked task');
+        //     });
+        //     it('should handle two-level nested task lists', () => {
+        //       const markdown = `- [ ] Parent task
+        //   - [ ] Child task 1
+        //   - [x] Child task 2`;
+        //       const html = markdownToHtml(markdown);
+        //       expect(html).toContain('Parent task');
+        //       expect(html).toContain('Child task 1');
+        //       expect(html).toContain('Child task 2');
+        //       expect(html).toMatch(/<ul>[\s\S]*<ul>/); // Nested ul elements
+        //     });
+        //     it('should handle three-level nested task lists', () => {
+        //       const markdown = `- [ ] Level 1
+        //   - [ ] Level 2
+        //     - [x] Level 3`;
+        //       const html = markdownToHtml(markdown);
+        //       expect(html).toContain('Level 1');
+        //       expect(html).toContain('Level 2');
+        //       expect(html).toContain('Level 3');
+        //       // Should have at least 3 ul elements for 3 levels
+        //       const ulCount = (html.match(/<ul>/g) || []).length;
+        //       expect(ulCount).toBeGreaterThanOrEqual(3);
+        //     });
+        //     it('should handle deeply nested task lists (5 levels)', () => {
+        //       const markdown = `- [ ] Level 1
+        //   - [ ] Level 2
+        //     - [ ] Level 3
+        //       - [ ] Level 4
+        //         - [x] Level 5`;
+        //       const html = markdownToHtml(markdown);
+        //       expect(html).toContain('Level 1');
+        //       expect(html).toContain('Level 5');
+        //       const ulCount = (html.match(/<ul>/g) || []).length;
+        //       expect(ulCount).toBeGreaterThanOrEqual(5);
+        //     });
+        //     it('should handle mixed task lists and regular lists', () => {
+        //       const markdown = `- [ ] Task item
+        //   - Regular nested item
+        //   - [ ] Nested task
+        // - Another regular item`;
+        //       const html = markdownToHtml(markdown);
+        //       expect(html).toContain('Task item');
+        //       expect(html).toContain('Regular nested item');
+        //       expect(html).toContain('Nested task');
+        //       expect(html).toContain('Another regular item');
+        //     });
+        //     it('should handle task lists with complex content', () => {
+        //       const markdown = `- [ ] Task with **bold** and *italic*
+        //   - [ ] Task with \`code\`
+        //   - [ ] Task with [link](https://example.com)`;
+        //       const html = markdownToHtml(markdown);
+        //       // Complex markdown inside task items may not be parsed yet
+        //       // This is a known limitation - task item text is not re-parsed for markdown
+        //       expect(html).toContain('Task with **bold** and *italic*');
+        //       expect(html).toContain('Task with `code`');
+        //       expect(html).toContain('Task with [link](https://example.com)');
+        //     });
+        it('should handle numbered lists', () => {
+            const markdown = '1. First item\n2. Second item\n3. Third item';
+            const html = markdownToHtml(markdown);
+            expect(html).toContain('<ol>');
+            expect(html).toContain('First item');
+            expect(html).toContain('Second item');
+        });
+        it('should handle code blocks', () => {
+            const markdown = '```javascript\nconst hello = "world";\n```';
+            const html = markdownToHtml(markdown);
+            expect(html).toContain('<pre>');
+            expect(html).toContain('<code');
+            expect(html).toContain('hello');
+        });
+        it('should handle blockquotes', () => {
+            const markdown = '> This is a quote';
+            const html = markdownToHtml(markdown);
+            expect(html).toContain('<blockquote>');
+            expect(html).toContain('This is a quote');
+        });
+    });
+    describe('htmlToMarkdown', () => {
+        it('should return empty string for empty input', () => {
+            expect(htmlToMarkdown('')).toBe('');
+            expect(htmlToMarkdown('  ')).toBe('');
+            expect(htmlToMarkdown(null)).toBe('');
+            expect(htmlToMarkdown(undefined)).toBe('');
+        });
+        it('should convert basic HTML to markdown', () => {
+            const html = '<h1>Heading 1</h1><p>This is a paragraph.</p><p><strong>Bold text</strong> and <em>italic text</em>.</p>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('# Heading 1');
+            expect(markdown).toContain('This is a paragraph.');
+            expect(markdown).toContain('**Bold text**');
+            // Turndown uses underscore for italic by default
+            expect(markdown).toContain('_italic text_');
+        });
+        it('should convert task list HTML back to markdown', () => {
+            const html = `<ul>
+        <li data-type="taskItem"><input type="checkbox" disabled> Unchecked task</li>
+        <li data-type="taskItem"><input type="checkbox" checked disabled> Checked task</li>
+      </ul>`;
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('-   [ ]  Unchecked task');
+            expect(markdown).toContain('-   [x]  Checked task');
+        });
+        it('should preserve two-level nested task list indentation', () => {
+            const html = `<ul>
+        <li data-type="taskItem"><input type="checkbox" disabled> Parent task
+          <ul>
+            <li data-type="taskItem"><input type="checkbox" disabled> Child task 1</li>
+            <li data-type="taskItem"><input type="checkbox" checked disabled> Child task 2</li>
+          </ul>
+        </li>
+      </ul>`;
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('-   [ ]  Parent task');
+            expect(markdown).toContain('    -   [ ]  Child task 1');
+            expect(markdown).toContain('    -   [x]  Child task 2');
+        });
+        it('should preserve three-level nested task list indentation', () => {
+            const html = `<ul>
+        <li data-type="taskItem"><input type="checkbox" disabled> Level 1
+          <ul>
+            <li data-type="taskItem"><input type="checkbox" disabled> Level 2
+              <ul>
+                <li data-type="taskItem"><input type="checkbox" checked disabled> Level 3</li>
+              </ul>
+            </li>
+          </ul>
+        </li>
+      </ul>`;
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('-   [ ]  Level 1');
+            expect(markdown).toContain('    -   [ ]  Level 2');
+            expect(markdown).toContain('        -   [x]  Level 3');
+        });
+        it('should handle regular nested lists', () => {
+            const html = `<ul>
+        <li>Parent item
+          <ul>
+            <li>Child item 1</li>
+            <li>Child item 2</li>
+          </ul>
+        </li>
+      </ul>`;
+            const markdown = htmlToMarkdown(html);
+            // Turndown may add extra spacing in lists
+            expect(markdown).toContain('Parent item');
+            expect(markdown).toContain('Child item 1');
+            expect(markdown).toContain('Child item 2');
+            // Check for proper nesting with indentation
+            expect(markdown).toMatch(/.*Child item 1/);
+        });
+        it('should handle numbered lists', () => {
+            const html = '<ol><li>First</li><li>Second</li><li>Third</li></ol>';
+            const markdown = htmlToMarkdown(html);
+            // Turndown may add extra spacing after the period
+            expect(markdown).toMatch(/1\.\s+First/);
+            expect(markdown).toMatch(/2\.\s+Second/);
+            expect(markdown).toMatch(/3\.\s+Third/);
+        });
+        it('should handle code blocks', () => {
+            const html = '<pre><code class="language-javascript">const hello = "world";</code></pre>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('```');
+            expect(markdown).toContain('const hello = "world";');
+        });
+        it('should handle inline code', () => {
+            const html = '<p>Use <code>npm install</code> to install.</p>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('`npm install`');
+        });
+        it('should handle links', () => {
+            const html = '<p>Visit <a href="https://example.com">example</a></p>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('[example](https://example.com)');
+        });
+        it('should handle blockquotes', () => {
+            const html = '<blockquote><p>This is a quote</p></blockquote>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('> This is a quote');
+        });
+        it('should handle horizontal rules', () => {
+            const html = '<hr>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('---');
+        });
+        it('should render list item', () => {
+            const html = '<li>Test</li>';
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('- Test');
+        });
+    });
+    //   describe('Round-trip conversion', () => {
+    //     it('should preserve simple task lists through round-trip conversion', () => {
+    //       const original = '- [ ] Task 1\n- [x] Task 2';
+    //       const html = markdownToHtml(original);
+    //       const result = htmlToMarkdown(html);
+    //       expect(result).toContain('- [ ] Task 1');
+    //       expect(result).toContain('- [x] Task 2');
+    //     });
+    //     it('should preserve two-level nested task lists through round-trip conversion', () => {
+    //       const original = `- [ ] Parent task
+    //   - [ ] Child task 1
+    //   - [x] Child task 2`;
+    //       const html = markdownToHtml(original);
+    //       const result = htmlToMarkdown(html);
+    //       expect(result).toContain('- [ ] Parent task');
+    //       expect(result).toContain('  - [ ] Child task 1');
+    //       expect(result).toContain('  - [x] Child task 2');
+    //     });
+    //     it('should preserve three-level nested task lists through round-trip conversion', () => {
+    //       const original = `- [ ] Level 1
+    //   - [ ] Level 2
+    //     - [x] Level 3`;
+    //       const html = markdownToHtml(original);
+    //       const result = htmlToMarkdown(html);
+    //       expect(result).toContain('- [ ] Level 1');
+    //       expect(result).toContain('  - [ ] Level 2');
+    //       expect(result).toContain('    - [x] Level 3');
+    //     });
+    //     it('should preserve complex nested task list structure', () => {
+    //       const original = `- [ ] Task 1
+    //   - [ ] Task 1.1
+    //   - [x] Task 1.2
+    //     - [ ] Task 1.2.1
+    //     - [ ] Task 1.2.2
+    // - [ ] Task 2
+    //   - [ ] Task 2.1`;
+    //       const html = markdownToHtml(original);
+    //       const result = htmlToMarkdown(html);
+    //       // Check all items are present
+    //       expect(result).toContain('- [ ] Task 1');
+    //       expect(result).toContain('  - [ ] Task 1.1');
+    //       expect(result).toContain('  - [x] Task 1.2');
+    //       expect(result).toContain('    - [ ] Task 1.2.1');
+    //       expect(result).toContain('    - [ ] Task 1.2.2');
+    //       expect(result).toContain('- [ ] Task 2');
+    //       expect(result).toContain('  - [ ] Task 2.1');
+    //     });
+    //     it('should handle task list with description formatting', () => {
+    //       const original = `- [ ] Add button to trigger task refinement
+    //   - [ ] **Description**: Clear explanation
+    //   - [ ] *Acceptance Criteria*: Tests pass
+    //   - [ ] \`Technical Details\`: Use React`;
+    //       const html = markdownToHtml(original);
+    //       const result = htmlToMarkdown(html);
+    //       expect(result).toContain('- [ ] Add button to trigger task refinement');
+    //       // Markdown inside task items may not be preserved through round-trip
+    //       // This is a known limitation of the current implementation
+    //       expect(result).toContain('Description');
+    //       expect(result).toContain('Acceptance Criteria');
+    //       expect(result).toContain('Technical Details');
+    //     });
+    //   });
+    describe('Edge cases', () => {
+        it('should handle malformed task list syntax gracefully', () => {
+            const markdown = '- [] Invalid task\n-[x] Another invalid\n- [ ] Valid task';
+            const html = markdownToHtml(markdown);
+            // Should still parse what it can
+            expect(html).toContain('Valid task');
+        });
+        // it('should handle empty task descriptions', () => {
+        //   const markdown = '- [ ] \n- [x] ';
+        //   const html = markdownToHtml(markdown);
+        //   expect(html).toContain('data-type="taskItem"');
+        // });
+        // it('should handle very deeply nested lists (10 levels)', () => {
+        //   let markdown = '- [ ] L1';
+        //   for (let i = 2; i <= 10; i++) {
+        //     markdown += '\n' + '  '.repeat(i - 1) + `- [ ] L${i}`;
+        //   }
+        //   const html = markdownToHtml(markdown);
+        //   const result = htmlToMarkdown(html);
+        //   expect(result).toContain('- [ ] L1');
+        //   expect(result).toContain('  '.repeat(9) + '- [ ] L10');
+        // });
+        it('should handle mixed content in list items', () => {
+            const html = `<ul>
+        <li data-type="taskItem"><input type="checkbox" disabled> Task with <strong>bold</strong> and <a href="#">link</a></li>
+      </ul>`;
+            const markdown = htmlToMarkdown(html);
+            expect(markdown).toContain('-   [ ]  Task with **bold** and [link](#)');
+        });
+        it('should strip extra whitespace properly', () => {
+            const html = `<ul>
+        <li data-type="taskItem">  <input type="checkbox" disabled>   Task with spaces   </li>
+      </ul>`;
+            const markdown = htmlToMarkdown(html);
+            expect(markdown.trim()).toBe('-   [ ]  Task with spaces');
+        });
+        it('should handle nested task lists properly', () => {
+            const nestedMarkdown = `- [ ] Parent task with nested items:
+  - [ ] Child task 1
+  - [x] Child task 2`;
+            const html = markdownToHtml(nestedMarkdown);
+            // Check that HTML contains proper nesting structure
+            expect(html).toContain('data-type="taskList"');
+            expect(html).toContain('data-type="taskItem"');
+            expect(html).toContain('data-checked="false"');
+            expect(html).toContain('data-checked="true"');
+            expect(html).toContain('Parent task with nested items:');
+            expect(html).toContain('Child task 1');
+            expect(html).toContain('Child task 2');
+            // Verify the nested structure is present in HTML
+            expect(html).toMatch(/<li[^>]*data-type="taskItem"[^>]*>.*<ul>.*<li[^>]*data-type="taskItem"/s);
+        });
+    });
+});

package/dist/runtime/api/lib/provider-detection.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Enhanced Provider Detection Service
+ * Robust detection logic for AI provider CLI tools with multiple fallback strategies
+ */
+export interface DetectionResult {
+    found: boolean;
+    path?: string;
+    version?: string;
+    method?: 'explicit' | 'PATH' | 'common-location';
+    error?: string;
+}
+export interface ProviderInfo {
+    name: string;
+    command: string;
+    versionArgsList?: string[][];
+    versionRegex: RegExp;
+}
+/**
+ * Provider definitions for detection
+ */
+export declare const PROVIDER_DEFINITIONS: Record<string, ProviderInfo>;
+/**
+ * Enhanced Provider Detection Service
+ */
+export declare class ProviderDetectionService {
+    private localConfig;
+    constructor();
+    /**
+     * Detect a specific provider with all fallback strategies
+     */
+    detectProvider(providerId: string): Promise<DetectionResult>;
+    /**
+     * Detect all configured providers
+     */
+    detectAllProviders(): Promise<Record<string, DetectionResult>>;
+    /**
+     * Validate a specific binary path
+     */
+    validateBinaryPath(binPath: string, provider: ProviderInfo, method?: DetectionResult['method']): Promise<DetectionResult>;
+    /**
+     * Set explicit provider path and cache it
+     */
+    setProviderPath(providerId: string, binPath: string): Promise<DetectionResult>;
+    /**
+     * Clear cached provider configuration
+     */
+    clearProviderPath(providerId: string): Promise<void>;
+    /**
+     * Get cached detection results if still fresh
+     */
+    getCachedResult(providerId: string): Promise<DetectionResult | null>;
+    private checkExplicitConfig;
+    private checkSystemCommand;
+    private getVersion;
+    private resolveCommand;
+    private toLocalConfigKey;
+    private cacheDetectionResult;
+}
+export declare function getProviderDetectionService(): ProviderDetectionService;

package/dist/runtime/api/lib/provider-detection.js

@@ -0,0 +1,244 @@
+/**
+ * Enhanced Provider Detection Service
+ * Robust detection logic for AI provider CLI tools with multiple fallback strategies
+ */
+import { exec, execFile } from 'child_process';
+import { promisify } from 'util';
+import fs from 'fs/promises';
+import which from 'which';
+import { log } from './logger.js';
+import { getLocalConfigService } from './local-config.js';
+const execAsync = promisify(exec);
+const execFileAsync = promisify(execFile);
+/**
+ * Provider definitions for detection
+ */
+export const PROVIDER_DEFINITIONS = {
+    'claude-code': {
+        name: 'Claude Code',
+        command: 'claude',
+        versionArgsList: [['--version'], ['-v']],
+        versionRegex: /(\d+\.\d+\.\d+)/,
+    },
+    codex: {
+        name: 'Codex CLI',
+        command: 'codex',
+        versionArgsList: [['--version'], ['-v']],
+        versionRegex: /(\d+\.\d+\.\d+)/,
+    },
+};
+/**
+ * Enhanced Provider Detection Service
+ */
+export class ProviderDetectionService {
+    constructor() {
+        this.localConfig = getLocalConfigService();
+        // Ensure local config is initialized
+        this.localConfig.initialize().catch((error) => {
+            log.error('Failed to initialize local config for provider detection', error, 'provider-detection');
+        });
+    }
+    /**
+     * Detect a specific provider with all fallback strategies
+     */
+    async detectProvider(providerId) {
+        const provider = PROVIDER_DEFINITIONS[providerId];
+        if (!provider) {
+            return {
+                found: false,
+                error: `Unknown provider: ${providerId}`,
+            };
+        }
+        log.debug(`Detecting provider: ${provider.name}`, { providerId }, 'provider-detection');
+        // Strategy 1: Check explicit configuration from local config
+        const explicitResult = await this.checkExplicitConfig(providerId, provider);
+        if (explicitResult.found) {
+            log.info(`Provider found via explicit config: ${provider.name}`, explicitResult, 'provider-detection');
+            return explicitResult;
+        }
+        // Strategy 2: Resolve via system command lookup
+        const systemResult = await this.checkSystemCommand(provider);
+        if (systemResult.found) {
+            log.info(`Provider found on system PATH: ${provider.name}`, systemResult, 'provider-detection');
+            await this.cacheDetectionResult(providerId, systemResult);
+            return systemResult;
+        }
+        // All strategies failed
+        const result = {
+            found: false,
+            error: `${provider.name} not found via explicit config or system PATH`,
+        };
+        log.warn(`Provider not found: ${provider.name}`, result, 'provider-detection');
+        return result;
+    }
+    /**
+     * Detect all configured providers
+     */
+    async detectAllProviders() {
+        const results = {};
+        for (const providerId of Object.keys(PROVIDER_DEFINITIONS)) {
+            try {
+                results[providerId] = await this.detectProvider(providerId);
+            }
+            catch (error) {
+                results[providerId] = {
+                    found: false,
+                    error: `Detection failed: ${error instanceof Error ? error.message : String(error)}`,
+                };
+            }
+        }
+        return results;
+    }
+    /**
+     * Validate a specific binary path
+     */
+    async validateBinaryPath(binPath, provider, method = 'explicit') {
+        try {
+            // Check if file exists and is executable
+            const stats = await fs.stat(binPath);
+            if (!stats.isFile()) {
+                return {
+                    found: false,
+                    error: `Path is not a file: ${binPath}`,
+                };
+            }
+            // Try to execute version command
+            const version = await this.getVersion(binPath, provider);
+            return {
+                found: true,
+                path: binPath,
+                version,
+                method,
+            };
+        }
+        catch (error) {
+            return {
+                found: false,
+                path: binPath,
+                error: `Validation failed: ${error instanceof Error ? error.message : String(error)}`,
+            };
+        }
+    }
+    /**
+     * Set explicit provider path and cache it
+     */
+    async setProviderPath(providerId, binPath) {
+        const provider = PROVIDER_DEFINITIONS[providerId];
+        if (!provider) {
+            return {
+                found: false,
+                error: `Unknown provider: ${providerId}`,
+            };
+        }
+        const result = await this.validateBinaryPath(binPath, provider);
+        if (result.found) {
+            const localId = this.toLocalConfigKey(providerId);
+            await this.localConfig.setProviderPath(localId, binPath, 'explicit');
+        }
+        return result;
+    }
+    /**
+     * Clear cached provider configuration
+     */
+    async clearProviderPath(providerId) {
+        const localId = this.toLocalConfigKey(providerId);
+        await this.localConfig.clearProviderPath(localId);
+    }
+    /**
+     * Get cached detection results if still fresh
+     */
+    async getCachedResult(providerId) {
+        if (this.localConfig.isCachedValidationFresh(providerId)) {
+            const cached = this.localConfig.getCachedValidationResult(providerId);
+            if (cached) {
+                const localId = this.toLocalConfigKey(providerId);
+                return {
+                    found: cached.available,
+                    path: cached.available
+                        ? this.localConfig.getProviderConfig(localId)?.detectedPath
+                        : undefined,
+                    version: cached.version,
+                    error: cached.error,
+                };
+            }
+        }
+        return null;
+    }
+    // Private detection strategies
+    async checkExplicitConfig(providerId, provider) {
+        const localId = this.toLocalConfigKey(providerId);
+        const config = this.localConfig.getProviderConfig(localId);
+        if (!config?.binPath) {
+            return { found: false };
+        }
+        return this.validateBinaryPath(config.binPath, provider, 'explicit');
+    }
+    async checkSystemCommand(provider) {
+        const resolvedPath = await this.resolveCommand(provider.command);
+        if (!resolvedPath) {
+            return { found: false };
+        }
+        return this.validateBinaryPath(resolvedPath, provider, 'PATH');
+    }
+    async getVersion(binPath, provider) {
+        const argSets = provider.versionArgsList ?? [['--version']];
+        for (const args of argSets) {
+            try {
+                const { stdout, stderr } = await execFileAsync(binPath, args, { timeout: 10000 });
+                const output = (stdout + stderr).trim();
+                const match = output.match(provider.versionRegex);
+                if (match?.[1]) {
+                    return match[1];
+                }
+            }
+            catch (error) {
+                log.debug(`Version command failed for ${binPath}`, { args, error }, 'provider-detection');
+            }
+        }
+        return undefined;
+    }
+    async resolveCommand(command) {
+        try {
+            return await which(command);
+        }
+        catch (error) {
+            log.debug(`which lookup failed for ${command}`, error, 'provider-detection');
+        }
+        if (process.platform !== 'win32') {
+            try {
+                const { stdout } = await execAsync(`command -v ${command}`, { timeout: 5000 });
+                const resolved = stdout.trim().split('\n')[0];
+                return resolved ? resolved : null;
+            }
+            catch (error) {
+                log.debug(`command -v lookup failed for ${command}`, error, 'provider-detection');
+            }
+        }
+        return null;
+    }
+    toLocalConfigKey(providerId) {
+        return providerId === 'claude-code' ? 'claude-code' : 'codex';
+    }
+    async cacheDetectionResult(providerId, result) {
+        if (result.found && result.path) {
+            const localId = this.toLocalConfigKey(providerId);
+            if (result.method === 'explicit') {
+                await this.localConfig.setProviderPath(localId, result.path, 'explicit');
+            }
+            else {
+                await this.localConfig.updateDetectedProvider(localId, result.path, result.method || 'PATH');
+            }
+        }
+        await this.localConfig.cacheValidationResult(providerId, {
+            available: result.found,
+            error: result.error,
+            version: result.version,
+        });
+    }
+}
+// Singleton instance
+let providerDetectionService = null;
+export function getProviderDetectionService() {
+    providerDetectionService ?? (providerDetectionService = new ProviderDetectionService());
+    return providerDetectionService;
+}

package/dist/runtime/api/lib/server/agent-service-singleton.d.ts

@@ -0,0 +1,6 @@
+import { AgentService } from '../../agent/agent-service.js';
+declare global {
+    var __vibeman_agent_service__: unknown;
+}
+export declare function getAgentService(): AgentService;
+export declare function resetAgentService(): void;