vibeman 0.0.5 → 0.0.7

package/dist/runtime/api/api/routers/worktrees.js

@@ -1,80 +0,0 @@
-import { z } from 'zod';
-import { publicProcedure } from '../trpc.js';
-import { TaskIdSchema, WorktreePathSchema, withErrors } from '../router-helpers.js';
-import { log } from '../../lib/logger.js';
-export function buildWorktreeRoutes({ vibingOrchestrator }) {
-    return {
-        listWorktrees: publicProcedure.query(withErrors('list worktrees', 'router:listWorktrees', async () => {
-            const orchestrator = vibingOrchestrator;
-            return await orchestrator.listWorktrees();
-        })),
-        syncWorktreeState: publicProcedure.mutation(withErrors('sync worktree state', 'router:syncWorktreeState', async () => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.syncWorktreeState();
-            return { success: true, message: 'Worktree state synchronized' };
-        })),
-        getWorktreeInfo: publicProcedure.input(TaskIdSchema).query(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            const worktree = orchestrator.getWorktreeInfo(input.taskId);
-            if (!worktree)
-                return null;
-            const { git, ...serializableWorktree } = worktree;
-            return serializableWorktree;
-        }),
-        createWorktree: publicProcedure.input(TaskIdSchema).mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            const worktree = await orchestrator.createWorktree(input.taskId);
-            const { git, ...serializableWorktree } = worktree;
-            return serializableWorktree;
-        }),
-        deleteWorktree: publicProcedure
-            .input(z.object({ taskId: z.string(), force: z.coerce.boolean().optional() }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.deleteWorktree(input.taskId, input.force || false);
-            if (orchestrator) {
-                await orchestrator.removeWorkflowsByTask(input.taskId);
-            }
-            return { success: true };
-        }),
-        openInEditor: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in editor', 'router:openInEditor', async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.openInEditor(input.worktreePath);
-            // Ensure we return a clean, serializable object
-            return { success: true };
-        })),
-        openInTerminal: publicProcedure.input(WorktreePathSchema).mutation(withErrors('open in terminal', 'router:openInTerminal', async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.openInTerminal(input.worktreePath);
-            // Ensure we return a clean, serializable object
-            return { success: true };
-        })),
-        // TODO: Deprecated alias; prefer createPullRequest
-        createWorktreePR: publicProcedure
-            .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            log.warn('Deprecated route used: createWorktreePR; prefer createPullRequest', { taskId: input.taskId }, 'router:createWorktreePR');
-            return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
-        }),
-        createPullRequest: publicProcedure
-            .input(z.object({ taskId: z.string(), baseBranch: z.string().optional().default('main') }))
-            .mutation(withErrors('create pull request', 'router:createPullRequest', async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            return await orchestrator.createPullRequest(input.taskId, input.baseBranch);
-        })),
-        cleanupWorktree: publicProcedure
-            .input(z.object({
-            taskId: z.string().optional(),
-            worktreePath: z.string().optional(),
-            branchName: z.string().optional(),
-            isConnectedToTask: z.boolean(),
-            force: z.coerce.boolean().optional().default(false),
-        }))
-            .mutation(async ({ input }) => {
-            const orchestrator = vibingOrchestrator;
-            await orchestrator.cleanupWorktree(input);
-            return { success: true };
-        }),
-    };
-}

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

@@ -1,118 +0,0 @@
-import { z } from 'zod';
-import superjson from 'superjson';
-import type { TaskService } from '../tasks/task-service.js';
-export interface Context {
-    taskService?: TaskService;
-}
-export declare const t: import("@trpc/server").TRPCRootObject<Context, object, {
-    transformer: typeof superjson;
-}, {
-    ctx: Context;
-    meta: object;
-    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
-    transformer: true;
-}>;
-export declare const router: import("@trpc/server").TRPCRouterBuilder<{
-    ctx: Context;
-    meta: object;
-    errorShape: import("@trpc/server").TRPCDefaultErrorShape;
-    transformer: true;
-}>;
-export declare const publicProcedure: import("@trpc/server").TRPCProcedureBuilder<Context, object, object, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, import("@trpc/server").TRPCUnsetMarker, false>;
-export declare const TaskCreateSchema: z.ZodObject<{
-    id: z.ZodOptional<z.ZodString>;
-    title: z.ZodString;
-    type: z.ZodEnum<["feature", "bug", "chore", "refactor", "test", "doc"]>;
-    status: z.ZodDefault<z.ZodEnum<["backlog", "in-progress", "review", "done"]>>;
-    tags: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    due_date: z.ZodOptional<z.ZodString>;
-    assignee: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    priority: z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>;
-    comments: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
-    content: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-    status: "backlog" | "in-progress" | "review" | "done";
-    priority: "low" | "medium" | "high";
-    title: string;
-    tags: string[];
-    assignee: string[];
-    comments: string[];
-    content: string;
-    id?: string | undefined;
-    due_date?: string | undefined;
-}, {
-    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
-    title: string;
-    content: string;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    id?: string | undefined;
-    tags?: string[] | undefined;
-    due_date?: string | undefined;
-    assignee?: string[] | undefined;
-    comments?: string[] | undefined;
-}>;
-export declare const TaskUpdateSchema: z.ZodObject<{
-    title: z.ZodOptional<z.ZodString>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "bug", "chore", "refactor", "test", "doc"]>>;
-    status: z.ZodOptional<z.ZodDefault<z.ZodEnum<["backlog", "in-progress", "review", "done"]>>>;
-    tags: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
-    due_date: z.ZodOptional<z.ZodOptional<z.ZodString>>;
-    assignee: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
-    priority: z.ZodOptional<z.ZodDefault<z.ZodEnum<["low", "medium", "high"]>>>;
-    comments: z.ZodOptional<z.ZodDefault<z.ZodArray<z.ZodString, "many">>>;
-    content: z.ZodOptional<z.ZodString>;
-} & {
-    id: z.ZodString;
-    deleted_at: z.ZodOptional<z.ZodString>;
-}, "strip", z.ZodTypeAny, {
-    id: string;
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    title?: string | undefined;
-    tags?: string[] | undefined;
-    due_date?: string | undefined;
-    assignee?: string[] | undefined;
-    comments?: string[] | undefined;
-    content?: string | undefined;
-    deleted_at?: string | undefined;
-}, {
-    id: string;
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    title?: string | undefined;
-    tags?: string[] | undefined;
-    due_date?: string | undefined;
-    assignee?: string[] | undefined;
-    comments?: string[] | undefined;
-    content?: string | undefined;
-    deleted_at?: string | undefined;
-}>;
-export declare const TaskFilterSchema: z.ZodObject<{
-    status: z.ZodOptional<z.ZodEnum<["backlog", "in-progress", "review", "done"]>>;
-    type: z.ZodOptional<z.ZodEnum<["feature", "bug", "chore", "refactor", "test", "doc"]>>;
-    priority: z.ZodOptional<z.ZodEnum<["low", "medium", "high"]>>;
-    tags: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
-    search: z.ZodOptional<z.ZodString>;
-    includeDeleted: z.ZodOptional<z.ZodBoolean>;
-    onlyDeleted: z.ZodOptional<z.ZodBoolean>;
-}, "strip", z.ZodTypeAny, {
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    search?: string | undefined;
-    tags?: string[] | undefined;
-    includeDeleted?: boolean | undefined;
-    onlyDeleted?: boolean | undefined;
-}, {
-    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
-    status?: "backlog" | "in-progress" | "review" | "done" | undefined;
-    priority?: "low" | "medium" | "high" | undefined;
-    search?: string | undefined;
-    tags?: string[] | undefined;
-    includeDeleted?: boolean | undefined;
-    onlyDeleted?: boolean | undefined;
-}>;

package/dist/runtime/api/api/trpc.js

@@ -1,34 +0,0 @@
-import { initTRPC } from '@trpc/server';
-import { z } from 'zod';
-import superjson from 'superjson';
-export const t = initTRPC.context().create({
-    transformer: superjson,
-});
-export const router = t.router;
-export const publicProcedure = t.procedure;
-// Input validation schemas
-export const TaskCreateSchema = z.object({
-    id: z.string().optional(), // Made optional - will be auto-generated if not provided
-    title: z.string(),
-    type: z.enum(['feature', 'bug', 'chore', 'refactor', 'test', 'doc']),
-    status: z.enum(['backlog', 'in-progress', 'review', 'done']).default('backlog'),
-    tags: z.array(z.string()).default([]),
-    due_date: z.string().optional(),
-    assignee: z.array(z.string()).default([]),
-    priority: z.enum(['low', 'medium', 'high']).default('medium'),
-    comments: z.array(z.string()).default([]),
-    content: z.string(),
-});
-export const TaskUpdateSchema = TaskCreateSchema.partial().extend({
-    id: z.string(),
-    deleted_at: z.string().optional(),
-});
-export const TaskFilterSchema = z.object({
-    status: z.enum(['backlog', 'in-progress', 'review', 'done']).optional(),
-    type: z.enum(['feature', 'bug', 'chore', 'refactor', 'test', 'doc']).optional(),
-    priority: z.enum(['low', 'medium', 'high']).optional(),
-    tags: z.array(z.string()).optional(),
-    search: z.string().optional(),
-    includeDeleted: z.boolean().optional(),
-    onlyDeleted: z.boolean().optional(),
-});

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

@@ -1,9 +0,0 @@
-/**
- * Starts a standalone HTTP server that serves tRPC over HTTP and WebSocket on the same port.
- * HTTP endpoint:   /trpc
- * WebSocket path:  /trpc
- */
-export declare function startApiServer({ port, host }: {
-    port: number;
-    host: string;
-}): Promise<void>;

package/dist/runtime/api/index.js

@@ -1,117 +0,0 @@
-import { createServer } from 'http';
-import { nodeHTTPRequestHandler } from '@trpc/server/adapters/node-http';
-import { applyWSSHandler } from '@trpc/server/adapters/ws';
-import { WebSocketServer } from 'ws';
-import { appRouter } from './lib/trpc/server.js';
-import { getTaskService } from './lib/server/task-service-singleton.js';
-import { log } from './lib/logger.js';
-import { pathToFileURL } from 'url';
-function getNumberEnv(name, fallback) {
-    const raw = process.env[name];
-    const n = raw ? Number(raw) : NaN;
-    return Number.isFinite(n) ? n : fallback;
-}
-/**
- * Starts a standalone HTTP server that serves tRPC over HTTP and WebSocket on the same port.
- * HTTP endpoint:   /trpc
- * WebSocket path:  /trpc
- */
-export async function startApiServer({ port, host }) {
-    const httpServer = createServer((req, res) => {
-        // Basic CORS for local dev
-        res.setHeader('Access-Control-Allow-Origin', '*');
-        res.setHeader('Access-Control-Allow-Methods', 'GET,POST,PUT,DELETE,OPTIONS');
-        res.setHeader('Access-Control-Allow-Headers', 'Content-Type,Authorization');
-        if (req.method === 'OPTIONS') {
-            res.writeHead(200);
-            res.end();
-            return;
-        }
-        if (req.url?.startsWith('/trpc')) {
-            const host = req.headers.host || 'localhost';
-            const url = new URL(req.url, `http://${host}`);
-            // Strip the /trpc prefix and any leading slash; omit query string
-            const rawPath = url.pathname.replace(/^\/trpc\/?/, '');
-            const trpcPath = rawPath.replace(/^\/+/, '');
-            return nodeHTTPRequestHandler({
-                router: appRouter,
-                createContext: () => ({ taskService: getTaskService() }),
-                req: req,
-                res: res,
-                path: trpcPath,
-            });
-        }
-        if (req.url === '/api/health') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ status: 'ok', timestamp: new Date().toISOString() }));
-            return;
-        }
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ error: 'Not Found' }));
-    });
-    // Share same HTTP server for WS, listening on /trpc
-    const wss = new WebSocketServer({ noServer: true });
-    // Upgrade handler for WebSocket path filtering
-    httpServer.on('upgrade', (request, socket, head) => {
-        const { url } = request;
-        if (!url || !url.startsWith('/trpc')) {
-            socket.destroy();
-            return;
-        }
-        wss.handleUpgrade(request, socket, head, (ws) => {
-            wss.emit('connection', ws, request);
-        });
-    });
-    // Hook tRPC WS handler
-    applyWSSHandler({
-        wss,
-        router: appRouter,
-        createContext: () => ({ taskService: getTaskService() }),
-    });
-    await new Promise((resolve) => {
-        httpServer.listen(port, host, () => resolve());
-    });
-    const addr = httpServer.address();
-    const actualPort = typeof addr === 'object' && addr && 'port' in addr ? addr.port : port;
-    log.info('API server listening', { port: actualPort, host, path: '/trpc' }, 'api-server');
-    console.log(`📡 API ready at http://${host}:${actualPort}/trpc (HTTP & WS)`);
-    // Graceful shutdown
-    const shutdown = () => {
-        try {
-            wss.close();
-        }
-        catch (error) {
-            log.error('Failed to close WebSocket server', error, 'api-server');
-        }
-        try {
-            httpServer.close();
-        }
-        catch (error) {
-            log.error('Failed to close HTTP server', error, 'api-server');
-        }
-        process.exit(0);
-    };
-    process.on('SIGINT', shutdown);
-    process.on('SIGTERM', shutdown);
-}
-// Self-executing entry when run directly under ESM (e.g., tsx src/index.ts or node dist/index.js)
-try {
-    const isMain = process.argv[1] ? pathToFileURL(process.argv[1]).href === import.meta.url : false;
-    if (isMain) {
-        const host = process.env.HOST || 'localhost';
-        const resolveApiPort = async () => {
-            const port = getNumberEnv('PORT', 3000);
-            return port + 1;
-        };
-        (async () => {
-            const port = await resolveApiPort();
-            startApiServer({ port, host }).catch((err) => {
-                console.error('Failed to start API server:', err);
-                process.exit(1);
-            });
-        })();
-    }
-}
-catch {
-    // ignore
-}

package/dist/runtime/api/lib/id-generator.d.ts

@@ -1,70 +0,0 @@
-/**
- * Unified ID generation utility for consistent ID creation across the application
- */
-export type IdPrefix = 'workflow' | 'exec' | 'improve' | 'merge' | 'review' | 'claude' | 'task' | 'session';
-interface IdGeneratorOptions {
-    /**
-     * Use UUID v4 for guaranteed uniqueness (default: true)
-     */
-    useUuid?: boolean;
-    /**
-     * Include timestamp for sortability (default: false)
-     */
-    includeTimestamp?: boolean;
-    /**
-     * Custom separator between parts (default: '_')
-     */
-    separator?: string;
-}
-/**
- * Generate a unique ID with consistent format
- *
- * @param prefix - The prefix to identify the ID type
- * @param options - Configuration options for ID generation
- * @returns A unique identifier string
- *
- * @example
- * generateId('workflow') // 'workflow_550e8400-e29b-41d4-a716-446655440000'
- * generateId('exec', { includeTimestamp: true }) // 'exec_1703123456789_550e8400-e29b-41d4'
- */
-export declare function generateId(prefix: IdPrefix | string, options?: IdGeneratorOptions): string;
-/**
- * Generate a short, human-readable ID (less secure, for display purposes)
- *
- * @param prefix - The prefix to identify the ID type
- * @returns A shorter identifier string
- *
- * @example
- * generateShortId('task') // 'task_a1b2c3d4'
- */
-export declare function generateShortId(prefix: IdPrefix | string): string;
-/**
- * Parse an ID to extract its components
- *
- * @param id - The ID to parse
- * @param separator - The separator used in the ID
- * @returns Parsed components of the ID
- */
-export declare function parseId(id: string, separator?: string): {
-    prefix: string;
-    timestamp?: number;
-    uuid?: string;
-    full: string;
-};
-/**
- * Validate if a string is a valid UUID v4
- */
-export declare function isValidUuid(id: string): boolean;
-/**
- * Extract the UUID portion from a prefixed ID
- */
-export declare function extractUuid(id: string): string | null;
-/**
- * Create a batch of IDs efficiently
- */
-export declare function generateBatchIds(prefix: IdPrefix | string, count: number, options?: IdGeneratorOptions): string[];
-/**
- * Generate a deterministic ID based on input (useful for idempotency)
- */
-export declare function generateDeterministicId(prefix: IdPrefix | string, input: string): Promise<string>;
-export {};

package/dist/runtime/api/lib/id-generator.js

@@ -1,123 +0,0 @@
-import { v4 as uuidv4 } from 'uuid';
-/**
- * Generate a unique ID with consistent format
- *
- * @param prefix - The prefix to identify the ID type
- * @param options - Configuration options for ID generation
- * @returns A unique identifier string
- *
- * @example
- * generateId('workflow') // 'workflow_550e8400-e29b-41d4-a716-446655440000'
- * generateId('exec', { includeTimestamp: true }) // 'exec_1703123456789_550e8400-e29b-41d4'
- */
-export function generateId(prefix, options = {}) {
-    const { useUuid = true, includeTimestamp = false, separator = '_' } = options;
-    const parts = [prefix];
-    if (includeTimestamp) {
-        // Use high-resolution timestamp for better uniqueness
-        parts.push(Date.now().toString());
-    }
-    if (useUuid) {
-        parts.push(uuidv4());
-    }
-    else {
-        // Fallback to crypto.randomUUID if available (browser/Node 19+)
-        if (typeof crypto !== 'undefined' && crypto.randomUUID) {
-            parts.push(crypto.randomUUID());
-        }
-        else {
-            // Legacy fallback with better entropy
-            const timestamp = Date.now();
-            const random1 = Math.random().toString(36).substring(2, 11);
-            const random2 = Math.random().toString(36).substring(2, 7);
-            const counter = getCounter();
-            parts.push(`${timestamp.toString(36)}${random1}${random2}${counter.toString(36)}`);
-        }
-    }
-    return parts.join(separator);
-}
-/**
- * Generate a short, human-readable ID (less secure, for display purposes)
- *
- * @param prefix - The prefix to identify the ID type
- * @returns A shorter identifier string
- *
- * @example
- * generateShortId('task') // 'task_a1b2c3d4'
- */
-export function generateShortId(prefix) {
-    const timestamp = Date.now().toString(36).slice(-4);
-    const random = Math.random().toString(36).substring(2, 6);
-    return `${prefix}_${timestamp}${random}`;
-}
-/**
- * Parse an ID to extract its components
- *
- * @param id - The ID to parse
- * @param separator - The separator used in the ID
- * @returns Parsed components of the ID
- */
-export function parseId(id, separator = '_') {
-    const parts = id.split(separator);
-    const result = {
-        prefix: parts[0] || '',
-        full: id,
-    };
-    // Check if second part is a timestamp (13+ digit number for millisecond timestamps)
-    // This avoids treating short numbers like "123" as timestamps
-    if (parts[1] && /^\d{13,}$/.test(parts[1])) {
-        result.timestamp = parseInt(parts[1], 10);
-        // When timestamp is present, UUID is the third part onward
-        result.uuid = parts.slice(2).join(separator);
-    }
-    else {
-        // No timestamp, so UUID is everything after the prefix
-        result.uuid = parts.slice(1).join(separator);
-    }
-    return result;
-}
-/**
- * Validate if a string is a valid UUID v4
- */
-export function isValidUuid(id) {
-    const uuidV4Regex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
-    return uuidV4Regex.test(id);
-}
-/**
- * Extract the UUID portion from a prefixed ID
- */
-export function extractUuid(id) {
-    const parts = id.split('_');
-    const lastPart = parts[parts.length - 1];
-    return isValidUuid(lastPart) ? lastPart : null;
-}
-// Counter for additional entropy in fallback ID generation
-let counter = 0;
-function getCounter() {
-    counter = (counter + 1) % 10000;
-    return counter;
-}
-/**
- * Create a batch of IDs efficiently
- */
-export function generateBatchIds(prefix, count, options) {
-    return Array.from({ length: count }, () => generateId(prefix, options));
-}
-/**
- * Generate a deterministic ID based on input (useful for idempotency)
- */
-export async function generateDeterministicId(prefix, input) {
-    // Use Web Crypto API if available
-    if (typeof crypto !== 'undefined' && crypto.subtle) {
-        const encoder = new TextEncoder();
-        const data = encoder.encode(input);
-        const hashBuffer = await crypto.subtle.digest('SHA-256', data);
-        const hashArray = Array.from(new Uint8Array(hashBuffer));
-        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, '0')).join('');
-        return `${prefix}_${hashHex.substring(0, 32)}`;
-    }
-    // Fallback for Node.js
-    const cryptoModule = await import('crypto');
-    const hash = cryptoModule.createHash('sha256').update(input).digest('hex');
-    return `${prefix}_${hash.substring(0, 32)}`;
-}