vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/types/settings.d.ts

@@ -0,0 +1,81 @@
+export interface VibemanSettings {
+    agents: {
+        defaultProvider: 'claude-code' | 'codex';
+        codingAgent: {
+            provider: 'claude-code' | 'codex';
+            model: 'claude-sonnet-4-20250514' | 'claude-opus-4-1-20250805' | 'claude-3-5-haiku-20241022' | 'gpt-5';
+            maxTokens?: number;
+        };
+        judgeAgent: {
+            provider: 'claude-code' | 'codex';
+            model: 'claude-sonnet-4-20250514' | 'claude-opus-4-1-20250805' | 'claude-3-5-haiku-20241022' | 'gpt-5';
+            maxTokens?: number;
+            reviewThresholdScore: number;
+        };
+        defaultPrompts: {
+            systemPrompt: string;
+            taskPrompt: string;
+        };
+        providers?: {
+            claudeCode?: {
+                binPath?: string;
+            };
+            codex?: {
+                binPath?: string;
+            };
+        };
+    };
+    defaultWorkflow: {
+        autoQualityChecks: boolean;
+        requireHumanApproval: boolean;
+        aiCodeReview: boolean;
+        maxImplementationAttempts: number;
+        autoCommit: boolean;
+    };
+    quality?: {
+        checks: Array<{
+            name: string;
+            command: string;
+            args?: string[];
+            timeout?: number;
+            enabled?: boolean;
+        }>;
+    };
+    development: {
+        vibeDir?: string;
+        git: {
+            defaultBranch: string;
+            worktreePath?: string;
+        };
+        editor?: {
+            type?: 'vscode' | 'cursor' | 'vim' | 'custom';
+            command?: string;
+            args?: string[];
+            name?: string;
+            openFileCommand?: string[];
+            openFolderCommand?: string[];
+        };
+        terminal?: {
+            type?: 'system' | 'iterm2' | 'warp' | 'custom';
+            command?: string;
+            args?: string[];
+            name?: string;
+            openCommand?: string[];
+        };
+    };
+    server: {
+        port: number;
+        host: string;
+        autoOpenBrowser: boolean;
+    };
+}
+export interface SettingsUpdateRequest {
+    path: string[];
+    value: unknown;
+}
+export interface SettingsValidationError {
+    path: string[];
+    message: string;
+    expected?: string;
+    received?: string;
+}

package/dist/runtime/api/types/settings.js

@@ -0,0 +1,2 @@
+// Settings types
+export {};

package/dist/runtime/api/types.d.ts

@@ -0,0 +1,2 @@
+export type { AppRouter } from './lib/trpc/server.js';
+export type { Context } from './api/trpc.js';

package/dist/runtime/api/types.js

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

package/dist/runtime/api/utils/env.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Environment utility functions
+ */
+export declare function isTestEnv(): boolean;
+export declare function isDevelopment(): boolean;
+export declare function isProduction(): boolean;

package/dist/runtime/api/utils/env.js

@@ -0,0 +1,12 @@
+/**
+ * Environment utility functions
+ */
+export function isTestEnv() {
+    return process.env.NODE_ENV === 'test';
+}
+export function isDevelopment() {
+    return process.env.NODE_ENV === 'development';
+}
+export function isProduction() {
+    return process.env.NODE_ENV === 'production';
+}

package/dist/runtime/api/utils/stripNextEnv.d.ts

@@ -0,0 +1,7 @@
+type Env = Record<string, string | undefined>;
+/**
+ * Returns a shallow copy of `env` with all variables that Next.js
+ * adds or forces removed.
+ */
+export declare function stripNextInjectedEnv(env?: Env): Env;
+export {};

package/dist/runtime/api/utils/stripNextEnv.js

@@ -0,0 +1,22 @@
+/**
+ * Returns a shallow copy of `env` with all variables that Next.js
+ * adds or forces removed.
+ */
+export function stripNextInjectedEnv(env = process.env) {
+    const nextExact = new Set([
+        '__NEXT_PRIVATE_ORIGIN',
+        '__NEXT_PROCESSED_ENV',
+        'NEXT_PRIVATE_TRACE_ID',
+        'NEXT_PRIVATE_WORKER',
+        'NEXT_RUNTIME',
+        'TURBOPACK',
+        'PORT',
+        'NODE_ENV',
+    ]);
+    const nextPrefixes = ['__NEXT_', 'NEXT_PRIVATE_']; // convenience
+    return Object.fromEntries(Object.entries(env).filter(([key]) => {
+        if (nextExact.has(key))
+            return false;
+        return !nextPrefixes.some((p) => key.startsWith(p));
+    }));
+}

package/dist/runtime/api/utils/title-slug.d.ts

@@ -0,0 +1,6 @@
+export declare function slugFromTitle(title: string, options?: {
+    maxWords?: number;
+    maxLen?: number;
+}): string;
+export declare function generateHumanTaskId(type: string, title: string, existingIds?: string[]): string;
+export declare function isValidTaskIdFormat(id: string): boolean;

package/dist/runtime/api/utils/title-slug.js

@@ -0,0 +1,77 @@
+import slugifyModule from 'slugify';
+// Normalize slugify's mixed ESM/CJS export so it stays callable for NodeNext builds
+const slugifyImpl = typeof slugifyModule === 'function'
+    ? slugifyModule
+    : slugifyModule.default;
+// Configure slugify for broad transliteration coverage
+const slugify = (input) => slugifyImpl(input, {
+    lower: true,
+    strict: true, // remove anything except letters, numbers and replace spaces with -
+    trim: true,
+});
+const ALPHABET = '23456789ABCDEFGHJKLMNPQRSTUVWXYZ';
+function randomSuffix(len = 3) {
+    let out = '';
+    for (let i = 0; i < len; i++) {
+        out += ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
+    }
+    return out;
+}
+export function slugFromTitle(title, options) {
+    const { maxWords = 4, maxLen = 24 } = options || {};
+    const base = slugify(title || '');
+    if (!base)
+        return '';
+    // limit to N words
+    const parts = base.split('-').filter(Boolean);
+    const limited = parts.slice(0, maxWords);
+    // enforce max length by dropping trailing words or trimming the last
+    let slug = limited.join('-');
+    if (slug.length > maxLen) {
+        while (slug.length > maxLen && limited.length > 1) {
+            limited.pop();
+            slug = limited.join('-');
+        }
+        if (slug.length > maxLen) {
+            slug = slug.slice(0, maxLen).replace(/-+$/, '');
+        }
+    }
+    return slug.toUpperCase();
+}
+export function generateHumanTaskId(type, title, existingIds = []) {
+    const typeMap = {
+        feature: 'FEAT',
+        bug: 'BUG',
+        chore: 'CHORE',
+        refactor: 'REF',
+        test: 'TEST',
+        doc: 'DOC',
+    };
+    const prefix = typeMap[(type || '').toLowerCase()] || 'TASK';
+    const slug = slugFromTitle(title);
+    // Fallback when transliteration is empty
+    const base = slug ? `${prefix}-${slug}` : `${prefix}`;
+    // ensure uniqueness with a short suffix; cap total length to 40
+    let attempt = 0;
+    while (attempt < 128) {
+        const suffix = randomSuffix(slug ? 3 : 4);
+        let candidate = slug ? `${base}-${suffix}` : `${base}-${suffix}`;
+        if (candidate.length > 40) {
+            // trim slug segment if too long
+            const over = candidate.length - 40;
+            const trimmedSlug = slug.slice(0, Math.max(0, slug.length - over)).replace(/-+$/, '');
+            candidate = trimmedSlug ? `${prefix}-${trimmedSlug}-${suffix}` : `${prefix}-${suffix}`;
+        }
+        if (!existingIds.includes(candidate))
+            return candidate;
+        attempt++;
+    }
+    // last resort
+    return `${prefix}-${randomSuffix(4)}`;
+}
+export function isValidTaskIdFormat(id) {
+    if (!id || id.length > 40)
+        return false;
+    // At least TYPE-SOMETHING (two segments), uppercase letters/digits separated by hyphens
+    return /^[A-Z0-9]+(?:-[A-Z0-9]+)+$/.test(id);
+}

package/dist/runtime/api/utils/url.d.ts

@@ -0,0 +1,2 @@
+export declare function buildUrlWithParam(pathname: string, searchParams: URLSearchParams, key: string, value?: string | null): string;
+export declare function isValidTaskId(id: string | null | undefined): id is string;

package/dist/runtime/api/utils/url.js

@@ -0,0 +1,19 @@
+export function buildUrlWithParam(pathname, searchParams, key, value) {
+    const sp = new URLSearchParams(searchParams);
+    if (value && value.length > 0) {
+        sp.set(key, value);
+    }
+    else {
+        sp.delete(key);
+    }
+    const qs = sp.toString();
+    return qs ? `${pathname}?${qs}` : pathname;
+}
+export function isValidTaskId(id) {
+    if (!id)
+        return false;
+    const up = String(id).toUpperCase();
+    if (up.length > 40)
+        return false;
+    return /^[A-Z0-9]+(?:-[A-Z0-9]+)+$/.test(up);
+}

package/dist/runtime/api/vcs/git-history-service.d.ts

@@ -0,0 +1,57 @@
+export interface TaskHistoryEntry {
+    commitHash: string;
+    shortHash: string;
+    author: string;
+    date: Date;
+    message: string;
+    changes: {
+        additions: number;
+        deletions: number;
+    };
+}
+export interface TaskFileContent {
+    commitHash: string;
+    content: string;
+    date: Date;
+    author: string;
+}
+export interface TaskDiffEntry {
+    fromHash: string;
+    toHash: string;
+    diff: string;
+    additions: number;
+    deletions: number;
+}
+export declare class GitHistoryService {
+    private git;
+    private projectRoot;
+    constructor(projectRoot?: string);
+    /**
+     * Get the history of changes for a specific task file
+     */
+    getTaskHistory(taskId: string, limit?: number): Promise<TaskHistoryEntry[]>;
+    /**
+     * Get the content of a task file at a specific commit
+     */
+    getTaskVersionContent(taskId: string, commitHash: string): Promise<TaskFileContent>;
+    /**
+     * Get the diff between two versions of a task file
+     */
+    getTaskDiff(taskId: string, fromHash: string, toHash: string): Promise<TaskDiffEntry>;
+    /**
+     * Check if Git repository exists and is properly configured
+     */
+    isGitRepositoryAvailable(): Promise<boolean>;
+    /**
+     * Get commit statistics for a specific file in a commit
+     */
+    private getCommitStats;
+    /**
+     * Check if a task file has been renamed or moved by tracking it through Git history
+     */
+    getTaskFileRenames(taskId: string): Promise<Array<{
+        oldPath: string;
+        newPath: string;
+        commitHash: string;
+    }>>;
+}

package/dist/runtime/api/vcs/git-history-service.js

@@ -0,0 +1,228 @@
+import { simpleGit } from 'simple-git';
+import { getProjectRoot } from '../lib/server/project-root.js';
+import { log } from '../lib/logger.js';
+import path from 'path';
+export class GitHistoryService {
+    constructor(projectRoot = getProjectRoot()) {
+        this.projectRoot = projectRoot;
+        this.git = simpleGit(projectRoot);
+    }
+    /**
+     * Get the history of changes for a specific task file
+     */
+    async getTaskHistory(taskId, limit = 50) {
+        try {
+            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
+            // Check if the task file exists in the current working directory
+            const taskExists = await this.git.raw(['ls-files', taskFilePath]).then((output) => output.trim().length > 0, () => false);
+            if (!taskExists) {
+                // File doesn't exist in Git, return empty history
+                return [];
+            }
+            // Use --follow to track file through renames and --no-merges to avoid merge commits
+            const logResult = await this.git.raw([
+                'log',
+                '--follow',
+                '--no-merges',
+                '--pretty=format:%H|%h|%an|%ad|%s',
+                '--date=iso',
+                `--max-count=${limit}`,
+                '--',
+                taskFilePath,
+            ]);
+            if (!logResult.trim()) {
+                return [];
+            }
+            const commits = logResult.trim().split('\n');
+            const history = [];
+            for (const commitLine of commits) {
+                const [hash, shortHash, author, dateStr, ...messageParts] = commitLine.split('|');
+                const message = messageParts.join('|'); // Rejoin in case message contains |
+                if (!hash || !shortHash || !author || !dateStr) {
+                    continue;
+                }
+                try {
+                    // Get the diff stats for this specific file in this commit
+                    const stats = await this.getCommitStats(hash, taskFilePath);
+                    history.push({
+                        commitHash: hash,
+                        shortHash,
+                        author,
+                        date: new Date(dateStr),
+                        message,
+                        changes: stats,
+                    });
+                }
+                catch (error) {
+                    log.warn('Failed to get stats for commit', { hash, error }, 'git-history-service');
+                    // Add entry without stats
+                    history.push({
+                        commitHash: hash,
+                        shortHash,
+                        author,
+                        date: new Date(dateStr),
+                        message,
+                        changes: { additions: 0, deletions: 0 },
+                    });
+                }
+            }
+            return history;
+        }
+        catch (error) {
+            log.error('Failed to get task history', { taskId, error }, 'git-history-service');
+            throw new Error(`Failed to retrieve history for task ${taskId}: ${String(error)}`);
+        }
+    }
+    /**
+     * Get the content of a task file at a specific commit
+     */
+    async getTaskVersionContent(taskId, commitHash) {
+        try {
+            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
+            // Get the file content at the specific commit
+            const content = await this.git.show([`${commitHash}:${taskFilePath}`]);
+            // Get commit information
+            const commitInfo = await this.git.raw([
+                'show',
+                '--pretty=format:%an|%ad',
+                '--date=iso',
+                '--no-patch',
+                commitHash,
+            ]);
+            const [author, dateStr] = commitInfo.trim().split('|');
+            return {
+                commitHash,
+                content,
+                date: new Date(dateStr),
+                author: author || 'Unknown',
+            };
+        }
+        catch (error) {
+            log.error('Failed to get task version content', { taskId, commitHash, error }, 'git-history-service');
+            throw new Error(`Failed to retrieve content for task ${taskId} at commit ${commitHash}: ${String(error)}`);
+        }
+    }
+    /**
+     * Get the diff between two versions of a task file
+     */
+    async getTaskDiff(taskId, fromHash, toHash) {
+        try {
+            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
+            // Get the diff between two commits for the specific file
+            const diff = await this.git.raw(['diff', `${fromHash}..${toHash}`, '--', taskFilePath]);
+            // Get diff stats
+            const stats = await this.git.raw([
+                'diff',
+                '--numstat',
+                `${fromHash}..${toHash}`,
+                '--',
+                taskFilePath,
+            ]);
+            let additions = 0;
+            let deletions = 0;
+            if (stats.trim()) {
+                const [addStr, delStr] = stats.trim().split('\t');
+                additions = parseInt(addStr, 10) || 0;
+                deletions = parseInt(delStr, 10) || 0;
+            }
+            return {
+                fromHash,
+                toHash,
+                diff,
+                additions,
+                deletions,
+            };
+        }
+        catch (error) {
+            log.error('Failed to get task diff', { taskId, fromHash, toHash, error }, 'git-history-service');
+            throw new Error(`Failed to get diff for task ${taskId} between ${fromHash} and ${toHash}: ${String(error)}`);
+        }
+    }
+    /**
+     * Check if Git repository exists and is properly configured
+     */
+    async isGitRepositoryAvailable() {
+        try {
+            const isRepo = await this.git.checkIsRepo();
+            return isRepo;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Get commit statistics for a specific file in a commit
+     */
+    async getCommitStats(commitHash, filePath) {
+        try {
+            // Get the parent commit hash
+            const parentHash = await this.git.raw(['rev-parse', `${commitHash}^`]).catch(() => {
+                // This is likely the initial commit, compare against empty tree
+                return '4b825dc642cb6eb9a060e54bf8d69288fbee4904'; // Git's empty tree hash
+            });
+            const stats = await this.git.raw([
+                'diff',
+                '--numstat',
+                parentHash.trim(),
+                commitHash,
+                '--',
+                filePath,
+            ]);
+            if (!stats.trim()) {
+                return { additions: 0, deletions: 0 };
+            }
+            const [addStr, delStr] = stats.trim().split('\t');
+            return {
+                additions: parseInt(addStr, 10) || 0,
+                deletions: parseInt(delStr, 10) || 0,
+            };
+        }
+        catch {
+            return { additions: 0, deletions: 0 };
+        }
+    }
+    /**
+     * Check if a task file has been renamed or moved by tracking it through Git history
+     */
+    async getTaskFileRenames(taskId) {
+        try {
+            const taskFilePath = path.join('.vibeman', 'tasks', `${taskId}.md`);
+            // Use git log --follow --name-status to track renames
+            const logResult = await this.git.raw([
+                'log',
+                '--follow',
+                '--name-status',
+                '--pretty=format:%H',
+                '--',
+                taskFilePath,
+            ]);
+            const renames = [];
+            const lines = logResult.trim().split('\n');
+            let currentCommit = '';
+            for (const line of lines) {
+                if (line.match(/^[a-f0-9]{40}$/)) {
+                    // This is a commit hash
+                    currentCommit = line;
+                }
+                else if (line.startsWith('R') && currentCommit) {
+                    // This is a rename operation (R100, R090, etc.)
+                    const parts = line.split('\t');
+                    if (parts.length >= 3) {
+                        const oldPath = parts[1];
+                        const newPath = parts[2];
+                        renames.push({
+                            oldPath,
+                            newPath,
+                            commitHash: currentCommit,
+                        });
+                    }
+                }
+            }
+            return renames;
+        }
+        catch (error) {
+            log.warn('Failed to get task file renames', { taskId, error }, 'git-history-service');
+            return [];
+        }
+    }
+}

package/dist/runtime/api/vcs/git-service.d.ts

@@ -0,0 +1,127 @@
+import { SimpleGit, VersionResult } from 'simple-git';
+import { Task } from '../types/index.js';
+export interface GitConfig {
+    remoteUrl?: string;
+    defaultBranch?: string;
+}
+export interface BranchInfo {
+    name: string;
+    exists: boolean;
+    isCurrentBranch: boolean;
+}
+export interface CommitInfo {
+    hash: string;
+    message: string;
+    author: string;
+    date: Date;
+}
+export interface WorktreeCreationResult {
+    path: string;
+    branchName: string;
+    existed: boolean;
+}
+export declare class GitService {
+    private git;
+    private config;
+    private projectRoot;
+    constructor(projectRoot?: string, config?: GitConfig);
+    /**
+     * Validate Git repository exists and is properly configured
+     */
+    initializeRepository(): Promise<void>;
+    /**
+     * Get current Git status
+     */
+    getStatus(): Promise<{
+        current: string;
+        staged: string[];
+        modified: string[];
+        untracked: string[];
+        ahead: number;
+        behind: number;
+    }>;
+    /**
+     * Generate branch name from task
+     */
+    generateBranchName(task: Task): string;
+    /**
+     * Create a new branch for a task
+     */
+    createBranch(task: Task, baseBranch?: string): Promise<BranchInfo>;
+    /**
+     * Stage and commit changes
+     */
+    commitChanges(task: Task, message?: string, files?: string[]): Promise<CommitInfo>;
+    /**
+     * Generate standardized commit message
+     */
+    generateCommitMessage(task: Task): string;
+    /**
+     * Get commit history for current branch
+     */
+    getCommitHistory(maxCount?: number): Promise<CommitInfo[]>;
+    /**
+     * Get Git version information
+     */
+    getGitVersion(): Promise<VersionResult>;
+    /**
+     * List all worktrees in the repository
+     */
+    listWorktrees(): Promise<{
+        path: string;
+        branch: string;
+        prunable?: boolean;
+    }[]>;
+    /**
+     * Parse git worktree list output
+     */
+    private parseWorktreeList;
+    /**
+     * Create a new worktree
+     */
+    createWorktree(worktreePath: string, branchName: string, branchExists?: boolean): Promise<void>;
+    /**
+     * Remove a worktree
+     */
+    removeWorktree(worktreePath: string, force?: boolean): Promise<void>;
+    /**
+     * Prune stale worktrees
+     */
+    pruneWorktrees(): Promise<void>;
+    /**
+     * Delete a local branch
+     */
+    deleteLocalBranch(branchName: string, force?: boolean): Promise<void>;
+    /**
+     * Check if branch exists locally
+     */
+    branchExists(branchName: string): Promise<boolean>;
+    /**
+     * Sync with remote repository
+     */
+    syncWithRemote(branchName?: string): Promise<void>;
+    /**
+     * Get Git instance for a specific directory
+     */
+    getGitInstance(directory: string): SimpleGit;
+    /**
+     * Check Git status for a specific directory
+     */
+    getGitStatus(directory: string): Promise<{
+        modified: string[];
+        staged: string[];
+        not_added: string[];
+    }>;
+    /**
+     * Check if directory has uncommitted changes
+     */
+    hasUncommittedChanges(directory?: string): Promise<boolean>;
+    /**
+     * Get log for a specific directory/worktree
+     */
+    getLog(directory: string, options: string[]): Promise<any>;
+    /**
+     * Push branch from specific directory
+     */
+    pushFromDirectory(directory: string, remote: string, branchName: string, options?: string[]): Promise<void>;
+}