vibeman 0.0.5 → 0.0.7

package/dist/runtime/api/lib/server/bootstrap.js

@@ -1,197 +0,0 @@
-/**
- * Server Bootstrap - Async-first service initialization
- *
- * Provides ordered initialization of core services before router creation,
- * ensuring all dependencies are ready for synchronous access during runtime.
- */
-import { log } from '../logger.js';
-import { getSettingsService } from '../../settings-service.js';
-import { TaskService } from '../../tasks/task-service.js';
-import { AgentService } from '../../agent/agent-service.js';
-import { GitService } from '../../vcs/git-service.js';
-import { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
-import { getProjectRoot, getVibeDir } from './project-root.js';
-// Ready-only service instances - throw if accessed before bootstrap
-let settingsService = null;
-let taskService = null;
-let agentService = null;
-let gitService = null;
-let worktreeService = null;
-let vibingOrchestrator = null;
-// Bootstrap completion promise for diagnostics/tests
-let ready = null;
-let isBootstrapped = false;
-// Default config fallback for VibingOrchestrator
-const getDefaultVibingConfig = () => ({
-    autoQualityChecks: true,
-    requireHumanApproval: true,
-    aiCodeReview: true,
-    retryPolicy: { maxImplementationAttempts: 3 },
-    autoCommit: false,
-});
-/**
- * Initialize core services in proper dependency order.
- * Must be called before any service getters or router creation.
- */
-export async function bootstrap() {
-    if (isBootstrapped) {
-        log.info('Bootstrap already completed, skipping');
-        return;
-    }
-    if (ready) {
-        log.info('Bootstrap already in progress, waiting...');
-        return ready;
-    }
-    const startTime = Date.now();
-    log.info('Starting server bootstrap', {}, 'bootstrap');
-    ready = (async () => {
-        try {
-            // Stage 1: Settings Service (foundation)
-            const settingsStart = Date.now();
-            settingsService = getSettingsService();
-            log.info('Settings service initialized', {
-                duration: Date.now() - settingsStart,
-            }, 'bootstrap');
-            // Stage 2: Task Service (depends on settings for vibeDir)
-            const taskStart = Date.now();
-            const settingsVibeDir = (() => {
-                try {
-                    const s = settingsService.getSettings();
-                    return s?.development?.vibeDir;
-                }
-                catch {
-                    return undefined;
-                }
-            })();
-            const vibeDir = settingsVibeDir ?? getVibeDir();
-            taskService = new TaskService(vibeDir);
-            await taskService.ensureInitialized();
-            log.info('Task service initialized', {
-                vibeDir,
-                duration: Date.now() - taskStart,
-            }, 'bootstrap');
-            // Stage 3: Git Service (independent)
-            const gitStart = Date.now();
-            const projectRoot = getProjectRoot();
-            const settingsDefaultBranch = (() => {
-                try {
-                    const s = settingsService.getSettings();
-                    return s?.development?.git?.defaultBranch;
-                }
-                catch {
-                    return undefined;
-                }
-            })();
-            const gitConfig = {
-                defaultBranch: settingsDefaultBranch || 'main',
-            };
-            gitService = new GitService(projectRoot, gitConfig);
-            log.info('Git service initialized', {
-                projectRoot,
-                defaultBranch: gitConfig.defaultBranch,
-                duration: Date.now() - gitStart,
-            }, 'bootstrap');
-            // Stage 4: Agent Service (depends on task service)
-            const agentStart = Date.now();
-            agentService = new AgentService(taskService, projectRoot);
-            log.info('Agent service initialized', {
-                duration: Date.now() - agentStart,
-            }, 'bootstrap');
-            // Stage 5: Worktree Service (depends on git service, settings)
-            const worktreeStart = Date.now();
-            worktreeService = agentService.getWorktreeService();
-            await worktreeService.initialize();
-            log.info('Worktree service initialized', {
-                duration: Date.now() - worktreeStart,
-            }, 'bootstrap');
-            // Stage 6: VibingOrchestrator (depends on all previous services)
-            const orchestratorStart = Date.now();
-            vibingOrchestrator = new VibingOrchestrator(taskService, agentService, worktreeService, getDefaultVibingConfig(), gitService);
-            await vibingOrchestrator.initialize();
-            log.info('VibingOrchestrator initialized', {
-                duration: Date.now() - orchestratorStart,
-            }, 'bootstrap');
-            isBootstrapped = true;
-            const totalDuration = Date.now() - startTime;
-            log.info('Server bootstrap completed', {
-                totalDuration,
-                stages: 6,
-            }, 'bootstrap');
-        }
-        catch (error) {
-            log.error('Server bootstrap failed', error, 'bootstrap');
-            throw error;
-        }
-    })();
-    return ready;
-}
-/**
- * Ready-only sync getters - throw if called before bootstrap
- */
-export function getBootstrappedSettingsService() {
-    if (!settingsService) {
-        throw new Error('Settings service not available - bootstrap() must be called first');
-    }
-    return settingsService;
-}
-export function getBootstrappedTaskService() {
-    if (!taskService) {
-        throw new Error('Task service not available - bootstrap() must be called first');
-    }
-    return taskService;
-}
-export function getBootstrappedAgentService() {
-    if (!agentService) {
-        throw new Error('Agent service not available - bootstrap() must be called first');
-    }
-    return agentService;
-}
-export function getBootstrappedGitService() {
-    if (!gitService) {
-        throw new Error('Git service not available - bootstrap() must be called first');
-    }
-    return gitService;
-}
-export function getBootstrappedWorktreeService() {
-    if (!worktreeService) {
-        throw new Error('Worktree service not available - bootstrap() must be called first');
-    }
-    return worktreeService;
-}
-export function getBootstrappedVibingOrchestrator() {
-    if (!vibingOrchestrator) {
-        throw new Error('VibingOrchestrator not available - bootstrap() must be called first');
-    }
-    return vibingOrchestrator;
-}
-/**
- * Get bootstrap completion promise for diagnostics/tests
- */
-export function getBootstrapReady() {
-    return ready;
-}
-/**
- * Check if bootstrap has completed
- */
-export function isBootstrapComplete() {
-    return isBootstrapped;
-}
-/**
- * Test bootstrap function that initializes against a temp workspace
- */
-export async function testBootstrap(tempWorkspace) {
-    // Reset bootstrap state for testing
-    settingsService = null;
-    taskService = null;
-    agentService = null;
-    gitService = null;
-    worktreeService = null;
-    vibingOrchestrator = null;
-    ready = null;
-    isBootstrapped = false;
-    // TODO: Implement temp workspace logic if needed
-    if (tempWorkspace) {
-        log.info('Test bootstrap with temp workspace', { tempWorkspace }, 'bootstrap');
-    }
-    return bootstrap();
-}

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

@@ -1,6 +0,0 @@
-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

@@ -1,47 +0,0 @@
-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

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

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

@@ -1,61 +0,0 @@
-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) {
-        const trimmedRoot = envRoot.trim();
-        if (path.isAbsolute(trimmedRoot)) {
-            return path.normalize(trimmedRoot);
-        }
-        const baseCandidates = [
-            process.env.VIBEMAN_PROJECT_ROOT_BASE,
-            process.env.INIT_CWD,
-            process.env.PWD,
-            process.cwd(),
-        ].filter((candidate) => !!candidate && candidate.trim().length > 0);
-        let fallbackResolved = null;
-        for (const base of baseCandidates) {
-            const resolved = path.resolve(base, trimmedRoot);
-            if (!fallbackResolved) {
-                fallbackResolved = resolved;
-            }
-            if (fs.existsSync(resolved)) {
-                return resolved;
-            }
-        }
-        if (fallbackResolved) {
-            return fallbackResolved;
-        }
-        return path.resolve(trimmedRoot);
-    }
-    // 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

@@ -1,7 +0,0 @@
-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

@@ -1,58 +0,0 @@
-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/vibeman-info.d.ts

@@ -1,5 +0,0 @@
-export interface VibemanInfo {
-    version?: string;
-    gitShortHash?: string;
-}
-export declare function getVibemanInfo(): Promise<VibemanInfo>;

package/dist/runtime/api/lib/server/vibeman-info.js

@@ -1,85 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { simpleGit } from 'simple-git';
-import { log } from '../logger.js';
-const moduleDir = path.dirname(fileURLToPath(import.meta.url));
-function readPackageJson(pkgPath) {
-    try {
-        return JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
-    }
-    catch (error) {
-        log.warn('Failed to read package.json', { error, path: pkgPath }, 'vibeman-info');
-        return null;
-    }
-}
-function findGitRoot(startDir) {
-    let dir = startDir;
-    const { root } = path.parse(dir);
-    while (true) {
-        if (fs.existsSync(path.join(dir, '.git'))) {
-            return dir;
-        }
-        if (dir === root)
-            break;
-        dir = path.dirname(dir);
-    }
-    return null;
-}
-function findPackageRoot(startDir, packageName) {
-    let dir = startDir;
-    const { root } = path.parse(dir);
-    while (true) {
-        const pkgPath = path.join(dir, 'package.json');
-        if (fs.existsSync(pkgPath)) {
-            const pkg = readPackageJson(pkgPath);
-            if (pkg?.name === packageName) {
-                return dir;
-            }
-        }
-        if (dir === root)
-            break;
-        dir = path.dirname(dir);
-    }
-    return null;
-}
-function readPackageVersion(pkgPath) {
-    const pkg = readPackageJson(pkgPath);
-    if (!pkg)
-        return undefined;
-    const version = pkg.version;
-    return typeof version === 'string' && version.trim().length > 0 ? version.trim() : undefined;
-}
-function resolveVibemanVersion(gitRoot, packageRoot) {
-    if (gitRoot) {
-        const cliPackage = path.join(gitRoot, 'apps', 'cli', 'package.json');
-        if (fs.existsSync(cliPackage)) {
-            const version = readPackageVersion(cliPackage);
-            if (version)
-                return version;
-        }
-    }
-    if (packageRoot) {
-        const cliPackage = path.join(packageRoot, 'package.json');
-        if (fs.existsSync(cliPackage)) {
-            return readPackageVersion(cliPackage);
-        }
-    }
-    return undefined;
-}
-export async function getVibemanInfo() {
-    const gitRoot = findGitRoot(moduleDir);
-    let gitShortHash;
-    if (gitRoot) {
-        try {
-            const hash = await simpleGit(gitRoot).revparse(['--short', 'HEAD']);
-            gitShortHash = hash.trim();
-        }
-        catch (error) {
-            log.warn('Failed to resolve Vibeman git hash', { error, gitRoot }, 'vibeman-info');
-        }
-    }
-    const packageRoot = findPackageRoot(moduleDir, '@vibeman/cli');
-    const version = resolveVibemanVersion(gitRoot, packageRoot);
-    return { version, gitShortHash };
-}

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

@@ -1,7 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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;
-        }
-    });
-}