vibeman 0.0.0 → 0.0.2

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

@@ -0,0 +1,310 @@
+import { z } from 'zod';
+import { on, EventEmitter } from 'events';
+import { publicProcedure } from '../trpc.js';
+import { TRPCError } from '@trpc/server';
+export function buildWorkflowRoutes({ vibingOrchestrator }) {
+    const OperationOverrideSchema = z.object({
+        provider: z.string().optional(),
+        model: z.string().optional(),
+    });
+    const WorkflowAIRoutingOverrides = z
+        .object({
+        execute_task: OperationOverrideSchema.optional(),
+        improve_task: OperationOverrideSchema.optional(),
+        ai_codereview: OperationOverrideSchema.optional(),
+        ai_merge: OperationOverrideSchema.optional(),
+    })
+        .partial();
+    const WorkflowConfig = z.object({
+        autoQualityChecks: z.boolean().optional(),
+        requireHumanApproval: z.boolean().optional(),
+        stepByStepMode: z.boolean().optional(),
+        autoCommit: z.boolean().optional(),
+        createPR: z.boolean().optional(),
+        autoMerge: z.boolean().optional(),
+        aiCodeReview: z.boolean().optional(),
+        aiRoutingOverrides: WorkflowAIRoutingOverrides.optional(),
+    });
+    const WorkflowConfigOpt = WorkflowConfig.optional();
+    return {
+        updateWorkflowOptions: publicProcedure
+            .input(z.object({ workflowId: z.string(), config: WorkflowConfig }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.updateWorkflowOptions(input.workflowId, input.config);
+            return { success: true };
+        }),
+        startWorkflow: publicProcedure
+            .input(z.object({ taskId: z.string(), config: WorkflowConfigOpt }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            const workflowId = await orchestrator.startWorkflow(input.taskId, input.config || {});
+            return { workflowId };
+        }),
+        continueWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            try {
+                const orchestrator = vibingOrchestrator;
+                await orchestrator.continueWorkflow(input.workflowId);
+                return { success: true };
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                console.error('continueWorkflow failed:', msg);
+                throw new TRPCError({ code: 'BAD_REQUEST', message: msg });
+            }
+        }),
+        runValidation: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.runValidation(input.workflowId);
+            return { success: true };
+        }),
+        runMerge: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            provider: z.string().optional(),
+            model: z.string().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.runMerge(input.workflowId, {
+                provider: input.provider,
+                model: input.model,
+            });
+            return { success: true };
+        }),
+        runCleanup: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.runCleanup(input.workflowId);
+            return { success: true };
+        }),
+        pauseWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.pauseWorkflow(input.workflowId);
+            return { success: true };
+        }),
+        resetWorkflow: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            deleteWorktree: z.boolean().optional(),
+            force: z.boolean().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.resetWorkflow(input.workflowId, {
+                deleteWorktree: input.deleteWorktree,
+                force: input.force,
+            });
+            return { success: true };
+        }),
+        approveWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string(), comments: z.string().optional() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.approveWorkflow(input.workflowId);
+            return { success: true };
+        }),
+        rejectWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string(), feedback: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.rejectWorkflow(input.workflowId, input.feedback);
+            return { success: true };
+        }),
+        onTaskWorkflowEvents: publicProcedure
+            .input(z.object({ taskId: z.string().optional() }).optional())
+            .subscription(async function* (opts) {
+            const input = opts.input;
+            const orchestrator = vibingOrchestrator;
+            const proxy = new EventEmitter();
+            const handleStarted = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'started', workflowId: workflow.id, workflow });
+            };
+            const handlePhaseChanged = (data) => {
+                if (!input?.taskId || data.workflow?.taskId === input.taskId) {
+                    // Dedupe terminal phases: completed/failed are emitted via dedicated events
+                    if (data.newPhase !== 'completed' && data.newPhase !== 'failed') {
+                        proxy.emit('data', {
+                            type: 'phase',
+                            workflowId: data.workflowId,
+                            phase: data.newPhase,
+                            workflow: data.workflow,
+                        });
+                    }
+                }
+            };
+            const handleCompleted = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'completed', workflowId: workflow.id, workflow });
+            };
+            const handleFailed = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'failed', workflowId: workflow.id, workflow });
+            };
+            // New: forward execution start events at the task level
+            const handleExecStarted = (data) => {
+                if (!input?.taskId || data?.workflow?.taskId === input.taskId) {
+                    proxy.emit('data', {
+                        type: 'phase',
+                        workflowId: data.workflowId,
+                        phase: data.phase || data.workflow?.phase,
+                        workflow: data.workflow,
+                        executionId: data.executionId,
+                    });
+                }
+            };
+            // Forward additional workflow lifecycle/snapshot events
+            const handleUpdated = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'updated', workflowId: workflow.id, workflow });
+            };
+            const handleDeleted = (info) => {
+                if (!input?.taskId || info?.taskId === input.taskId)
+                    proxy.emit('data', { type: 'deleted', workflowId: info.workflowId });
+            };
+            const handlePaused = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'updated', workflowId: workflow.id, workflow });
+            };
+            const handleOptionsUpdated = (workflow) => {
+                if (!input?.taskId || workflow.taskId === input.taskId)
+                    proxy.emit('data', { type: 'updated', workflowId: workflow.id, workflow });
+            };
+            orchestrator.on('workflowStarted', handleStarted);
+            orchestrator.on('workflowPhaseChanged', handlePhaseChanged);
+            orchestrator.on('workflowCompleted', handleCompleted);
+            orchestrator.on('workflowFailed', handleFailed);
+            orchestrator.on('workflowExecutionStarted', handleExecStarted);
+            orchestrator.on('workflowUpdated', handleUpdated);
+            orchestrator.on('workflowDeleted', handleDeleted);
+            orchestrator.on('workflowPaused', handlePaused);
+            orchestrator.on('workflowOptionsUpdated', handleOptionsUpdated);
+            try {
+                for await (const [payload] of on(proxy, 'data', { signal: opts.signal })) {
+                    yield payload;
+                }
+            }
+            finally {
+                orchestrator.off('workflowStarted', handleStarted);
+                orchestrator.off('workflowPhaseChanged', handlePhaseChanged);
+                orchestrator.off('workflowCompleted', handleCompleted);
+                orchestrator.off('workflowFailed', handleFailed);
+                orchestrator.off('workflowExecutionStarted', handleExecStarted);
+                orchestrator.off('workflowUpdated', handleUpdated);
+                orchestrator.off('workflowDeleted', handleDeleted);
+                orchestrator.off('workflowPaused', handlePaused);
+                orchestrator.off('workflowOptionsUpdated', handleOptionsUpdated);
+            }
+        }),
+        // Additional workflow helpers used by UI
+        getWorkflow: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .query(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            return orchestrator.getWorkflow(input.workflowId);
+        }),
+        getWorkflowsByTaskId: publicProcedure
+            .input(z.object({ taskId: z.string() }))
+            .query(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            return orchestrator.getTaskWorkflows(input.taskId);
+        }),
+        getLatestWorkflowByTaskId: publicProcedure
+            .input(z.object({ taskId: z.string() }))
+            .query(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            return orchestrator.getLatestWorkflowByTask(input.taskId);
+        }),
+        aiReviewCode: publicProcedure
+            .input(z.object({
+            taskId: z.string(),
+            workflowId: z.string().optional(),
+            reviewContext: z.string().optional(),
+            provider: z.string().optional(),
+            model: z.string().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            const overrides = input.provider || input.model
+                ? { provider: input.provider, model: input.model }
+                : undefined;
+            return await orchestrator.aiReviewCode(input.taskId, input.reviewContext, {
+                workflowId: input.workflowId,
+                overrides,
+            });
+        }),
+        approveAndContinueReview: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.approveAndContinueReview(input.workflowId);
+            return { success: true };
+        }),
+        markCompleted: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.markWorkflowCompleted(input.workflowId);
+            return { success: true };
+        }),
+        checkWorktreeStatus: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            return await orchestrator.checkWorktreeStatus(input.workflowId);
+        }),
+        rerunImplementation: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            feedback: z.string().optional(),
+            provider: z.string().optional(),
+            model: z.string().optional(),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.rerunImplementation(input.workflowId, input.feedback, {
+                provider: input.provider,
+                model: input.model,
+            });
+            return { success: true };
+        }),
+        skipToNextPhase: publicProcedure
+            .input(z.object({ workflowId: z.string() }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.skipToNextPhase(input.workflowId);
+            return { success: true };
+        }),
+        rerunFromPhase: publicProcedure
+            .input(z.object({
+            workflowId: z.string(),
+            phase: z.enum([
+                'draft',
+                'implementing',
+                'validating',
+                'ai-reviewing',
+                'awaiting-review',
+                'paused',
+                'approved',
+                'merging',
+                'merged',
+                'cleaning',
+                'completed',
+                'failed',
+            ]),
+        }))
+            .mutation(async ({ input }) => {
+            const orchestrator = vibingOrchestrator;
+            await orchestrator.rerunPhase(input.workflowId, input.phase);
+            return { success: true };
+        }),
+    };
+}

package/dist/runtime/api/api/routers/worktrees.d.ts

@@ -0,0 +1,101 @@
+import type { VibingOrchestrator } from '../../workflows/vibing-orchestrator.js';
+type Deps = {
+    vibingOrchestrator: VibingOrchestrator;
+};
+export declare function buildWorktreeRoutes({ vibingOrchestrator }: Deps): {
+    readonly listWorktrees: import("@trpc/server").TRPCQueryProcedure<{
+        input: void;
+        output: (import("../../types/index.js").WorktreeInfo & {
+            isConnectedToTask: boolean;
+        })[];
+        meta: object;
+    }>;
+    readonly syncWorktreeState: import("@trpc/server").TRPCMutationProcedure<{
+        input: void;
+        output: {
+            readonly success: true;
+            readonly message: "Worktree state synchronized";
+        };
+        meta: object;
+    }>;
+    readonly getWorktreeInfo: import("@trpc/server").TRPCQueryProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    readonly createWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+        };
+        output: any;
+        meta: object;
+    }>;
+    readonly deleteWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            force?: boolean | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly openInEditor: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worktreePath: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly openInTerminal: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            worktreePath: string;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+    readonly createWorktreePR: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            pullRequest?: any;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    readonly createPullRequest: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            taskId: string;
+            baseBranch?: string | undefined;
+        };
+        output: {
+            success: boolean;
+            pullRequest?: any;
+            error?: string;
+        };
+        meta: object;
+    }>;
+    readonly cleanupWorktree: import("@trpc/server").TRPCMutationProcedure<{
+        input: {
+            isConnectedToTask: boolean;
+            taskId?: string | undefined;
+            force?: boolean | undefined;
+            worktreePath?: string | undefined;
+            branchName?: string | undefined;
+        };
+        output: {
+            readonly success: true;
+        };
+        meta: object;
+    }>;
+};
+export {};

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

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

@@ -0,0 +1,118 @@
+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, {
+    status: "review" | "in-progress" | "backlog" | "done";
+    title: string;
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+    tags: string[];
+    assignee: string[];
+    priority: "high" | "medium" | "low";
+    comments: string[];
+    content: string;
+    id?: string | undefined;
+    due_date?: string | undefined;
+}, {
+    title: string;
+    type: "feature" | "bug" | "chore" | "refactor" | "test" | "doc";
+    content: string;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+    id?: string | undefined;
+    tags?: string[] | undefined;
+    due_date?: string | undefined;
+    assignee?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | 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;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+    title?: string | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    tags?: string[] | undefined;
+    due_date?: string | undefined;
+    assignee?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | undefined;
+    comments?: string[] | undefined;
+    content?: string | undefined;
+    deleted_at?: string | undefined;
+}, {
+    id: string;
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+    title?: string | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    tags?: string[] | undefined;
+    due_date?: string | undefined;
+    assignee?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | 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, {
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    tags?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | undefined;
+    search?: string | undefined;
+    includeDeleted?: boolean | undefined;
+    onlyDeleted?: boolean | undefined;
+}, {
+    status?: "review" | "in-progress" | "backlog" | "done" | undefined;
+    type?: "feature" | "bug" | "chore" | "refactor" | "test" | "doc" | undefined;
+    tags?: string[] | undefined;
+    priority?: "high" | "medium" | "low" | undefined;
+    search?: string | undefined;
+    includeDeleted?: boolean | undefined;
+    onlyDeleted?: boolean | undefined;
+}>;

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

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

@@ -0,0 +1,9 @@
+/**
+ * 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>;