vibeman 0.0.0 → 0.0.1

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/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;

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

@@ -0,0 +1,27 @@
+import { AgentService } from '../../agent/agent-service.js';
+import { getTaskService } from './task-service-singleton.js';
+import { getSettingsService } from '../../settings-service.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+export function getAgentService() {
+    if (!globalThis.__vibeman_agent_service__) {
+        const taskService = getTaskService();
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const projectRoot = getProjectRoot();
+        const vibeDir = settingsVibeDir || getVibeDir();
+        globalThis.__vibeman_agent_service__ = new AgentService(taskService, projectRoot);
+        console.log(`🤖 Agent Service initialized (projectRoot=${projectRoot}, vibeDir=${vibeDir})`);
+    }
+    return globalThis.__vibeman_agent_service__;
+}
+export function resetAgentService() {
+    globalThis.__vibeman_agent_service__ = undefined;
+}

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

@@ -0,0 +1,6 @@
+import { GitService, GitConfig } from '../../vcs/git-service.js';
+declare global {
+    var __vibeman_git_service__: unknown;
+}
+export declare function getGitService(config?: GitConfig): GitService;
+export declare function resetGitService(): void;

package/dist/runtime/api/lib/server/git-service-singleton.js

@@ -0,0 +1,47 @@
+import { GitService } from '../../vcs/git-service.js';
+import { getSettingsService } from '../../settings-service.js';
+import { getProjectRoot, getVibeDir } from './project-root.js';
+export function getGitService(config) {
+    if (!globalThis.__vibeman_git_service__) {
+        // Resolve project root robustly (handles being launched from apps/api)
+        const projectRoot = getProjectRoot();
+        // Get vibeDir from settings, fallback to detected project .vibeman
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const vibeDir = settingsVibeDir || getVibeDir();
+        // Prefer settings default branch; fall back to 'main'
+        const settingsDefaultBranch = (() => {
+            try {
+                const svc = getSettingsService();
+                // Best effort; initialize may not have been awaited here
+                // but service returns defaults if not yet loaded from disk
+                const s = svc.getSettings();
+                return s?.development?.git?.defaultBranch;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const envConfig = {
+            defaultBranch: settingsDefaultBranch || 'main',
+        };
+        globalThis.__vibeman_git_service__ = new GitService(projectRoot, {
+            ...envConfig,
+            ...config,
+        });
+        const settingsInfo = { defaultBranch: envConfig.defaultBranch };
+        console.log(`🔧 Git Service initialized (root=${projectRoot}, vibeDir=${vibeDir}, defaultBranch=${settingsInfo.defaultBranch})`);
+    }
+    return globalThis.__vibeman_git_service__;
+}
+export function resetGitService() {
+    globalThis.__vibeman_git_service__ = undefined;
+}

package/dist/runtime/api/lib/server/project-root.d.ts

@@ -0,0 +1,2 @@
+export declare function getProjectRoot(): string;
+export declare function getVibeDir(): string;

package/dist/runtime/api/lib/server/project-root.js

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import path from 'path';
+// Find the repository project root by walking up from CWD
+// Preference order:
+// - env VIBEMAN_PROJECT_ROOT
+// - nearest directory containing .git or .vibeman
+// - fallback to process.cwd()
+export function getProjectRoot() {
+    const envRoot = process.env.VIBEMAN_PROJECT_ROOT;
+    if (envRoot && envRoot.trim().length > 0) {
+        return path.resolve(envRoot);
+    }
+    // First preference: directory that contains a .git directory/file
+    let dir = process.cwd();
+    const { root } = path.parse(dir);
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.git'))) {
+            return dir;
+        }
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    // Fallback: nearest directory with .vibeman (if repo is checked out without .git, e.g. tarball)
+    dir = process.cwd();
+    while (true) {
+        if (fs.existsSync(path.join(dir, '.vibeman'))) {
+            return dir;
+        }
+        if (dir === root)
+            break;
+        dir = path.dirname(dir);
+    }
+    return process.cwd();
+}
+export function getVibeDir() {
+    return path.join(getProjectRoot(), '.vibeman');
+}

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

@@ -0,0 +1,7 @@
+import { TaskService } from '../../tasks/task-service.js';
+declare global {
+    var __vibeman_task_service__: unknown;
+    var __vibeman_task_service_init__: unknown;
+}
+export declare function getTaskService(): TaskService;
+export declare function getTaskServiceAsync(): Promise<TaskService>;

package/dist/runtime/api/lib/server/task-service-singleton.js

@@ -0,0 +1,58 @@
+import { getSettingsService } from '../../settings-service.js';
+import { TaskService } from '../../tasks/task-service.js';
+import { isProduction } from '../../utils/env.js';
+import { getVibeDir } from './project-root.js';
+export function getTaskService() {
+    if (!globalThis.__vibeman_task_service__) {
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        // Ensure we use the repo-level .vibeman even when launched from a subpackage
+        const vibeDir = settingsVibeDir ?? getVibeDir();
+        globalThis.__vibeman_task_service__ = new TaskService(vibeDir);
+        console.log(`🗂️ Task Service initialized (vibeDir=${vibeDir})`);
+        globalThis.__vibeman_task_service__
+            .ensureInitialized()
+            .catch((e) => console.error('TaskService init error:', e));
+    }
+    return globalThis.__vibeman_task_service__;
+}
+export async function getTaskServiceAsync() {
+    if (globalThis.__vibeman_task_service__) {
+        return globalThis.__vibeman_task_service__;
+    }
+    if (!globalThis.__vibeman_task_service_init__) {
+        const settingsVibeDir = (() => {
+            try {
+                const svc = getSettingsService();
+                const s = svc.getSettings();
+                return s?.development?.vibeDir;
+            }
+            catch {
+                return undefined;
+            }
+        })();
+        const vibeDir = settingsVibeDir ?? getVibeDir();
+        globalThis.__vibeman_task_service__ = new TaskService(vibeDir);
+        globalThis.__vibeman_task_service_init__ = globalThis.__vibeman_task_service__
+            .initialize()
+            .then(() => globalThis.__vibeman_task_service__);
+    }
+    return globalThis.__vibeman_task_service_init__;
+}
+// Cleanup on process exit
+if (isProduction()) {
+    process.on('SIGTERM', () => {
+        if (globalThis.__vibeman_task_service__) {
+            globalThis.__vibeman_task_service__.stop();
+            globalThis.__vibeman_task_service__ = undefined;
+        }
+    });
+}

package/dist/runtime/api/lib/server/vibing-orchestrator-singleton.d.ts

@@ -0,0 +1,7 @@
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+declare global {
+    var __vibeman_vibing_orchestrator__: unknown;
+    var __vibeman_vibing_orchestrator_init__: unknown;
+}
+export declare function getVibingOrchestrator(): VibingOrchestrator;
+export declare function getVibingOrchestratorAsync(): Promise<VibingOrchestrator>;

package/dist/runtime/api/lib/server/vibing-orchestrator-singleton.js

@@ -0,0 +1,57 @@
+import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+import { getTaskService } from './task-service-singleton.js';
+import { getAgentService } from './agent-service-singleton.js';
+import { getGitService } from './git-service-singleton.js';
+import { isProduction } from '../../utils/env.js';
+// Default config fallback for VibingOrchestrator
+const getDefaultVibingConfig = () => ({
+    autoQualityChecks: true,
+    requireHumanApproval: true,
+    aiCodeReview: true,
+    retryPolicy: { maxImplementationAttempts: 3 },
+    autoCommit: false,
+});
+export function getVibingOrchestrator() {
+    if (!globalThis.__vibeman_vibing_orchestrator__) {
+        const taskService = getTaskService();
+        const agentService = getAgentService();
+        const gitService = getGitService();
+        globalThis.__vibeman_vibing_orchestrator__ = new VibingOrchestrator(taskService, agentService, agentService.getWorktreeService(), getDefaultVibingConfig(), gitService);
+    }
+    // Kick off one-time initialization in background (non-blocking)
+    if (!globalThis.__vibeman_vibing_orchestrator_init__) {
+        globalThis.__vibeman_vibing_orchestrator_init__ = globalThis.__vibeman_vibing_orchestrator__
+            .initialize()
+            .catch((e) => console.error('VibingOrchestrator init error:', e))
+            .finally(() => {
+            globalThis.__vibeman_vibing_orchestrator_init__ = undefined;
+        });
+    }
+    return globalThis.__vibeman_vibing_orchestrator__;
+}
+export async function getVibingOrchestratorAsync() {
+    if (globalThis.__vibeman_vibing_orchestrator__) {
+        return globalThis.__vibeman_vibing_orchestrator__;
+    }
+    if (!globalThis.__vibeman_vibing_orchestrator_init__) {
+        const taskService = getTaskService();
+        const agentService = getAgentService();
+        const gitService = getGitService();
+        globalThis.__vibeman_vibing_orchestrator__ = new VibingOrchestrator(taskService, agentService, agentService.getWorktreeService(), getDefaultVibingConfig(), gitService);
+        globalThis.__vibeman_vibing_orchestrator_init__ = globalThis.__vibeman_vibing_orchestrator__
+            .initialize()
+            .catch((e) => console.error('VibingOrchestrator init error:', e));
+    }
+    await globalThis.__vibeman_vibing_orchestrator_init__;
+    return globalThis.__vibeman_vibing_orchestrator__;
+}
+// Cleanup on process exit
+if (isProduction()) {
+    process.on('SIGTERM', () => {
+        if (globalThis.__vibeman_vibing_orchestrator__) {
+            // VibingOrchestrator doesn't have a stop method, but we can clean up the reference
+            globalThis.__vibeman_vibing_orchestrator__ = undefined;
+            globalThis.__vibeman_vibing_orchestrator_init__ = undefined;
+        }
+    });
+}

package/dist/runtime/api/lib/tiptap-utils.clamp-selection.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/runtime/api/lib/tiptap-utils.clamp-selection.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect } from 'vitest';
+import { clampSelectionPos } from './tiptap-utils.js';
+describe('clampSelectionPos', () => {
+    it('keeps positions within valid range', () => {
+        const res = clampSelectionPos(5, 8, 20);
+        expect(res).toEqual({ from: 5, to: 8 });
+    });
+    it('clamps underflow to 1', () => {
+        const res = clampSelectionPos(-10, 0, 20);
+        expect(res).toEqual({ from: 1, to: 1 });
+    });
+    it('clamps overflow to doc.nodeSize - 2', () => {
+        const res = clampSelectionPos(100, 200, 20);
+        // maxPos = 18 for nodeSize 20
+        expect(res).toEqual({ from: 18, to: 18 });
+    });
+    it('orders from/to when anchor > head', () => {
+        const res = clampSelectionPos(10, 5, 20);
+        expect(res).toEqual({ from: 5, to: 10 });
+    });
+    it('handles tiny documents safely', () => {
+        const res0 = clampSelectionPos(5, 6, 0);
+        expect(res0).toEqual({ from: 1, to: 1 });
+        const res1 = clampSelectionPos(2, 3, 1);
+        expect(res1).toEqual({ from: 1, to: 1 });
+    });
+});