vibeman 0.0.0 → 0.0.1

package/dist/runtime/api/agent/prompt-service.js

@@ -0,0 +1,340 @@
+import path from 'path';
+import fs from 'fs/promises';
+import { log } from '../lib/logger.js';
+import { getVibeDir } from '../lib/server/project-root.js';
+// -----------------------------
+// Prompt templates (hard-coded)
+// -----------------------------
+const IMPROVEMENT_TEMPLATE = `The current content might be a brief description or incomplete specification. Transform it into a comprehensive, well-structured task specification using advanced reasoning.
+
+## Analysis Framework
+
+First, conduct a thorough analysis:
+
+1. **Current State Assessment**: Analyze the existing task content for clarity, completeness, and specificity
+2. **Type Classification**: Evaluate if the current type ({{taskType}}) aligns with the actual work required:
+   - **feature**: New functionality or capabilities
+   - **bug**: Fixing defects or issues
+   - **chore**: Maintenance, dependencies, tooling
+   - **refactor**: Code improvement without behavior change
+   - **test**: Adding or improving tests
+   - **doc**: Documentation updates
+
+3. **Priority Assessment**: Evaluate if the current priority ({{taskPriority}}) reflects the business impact and urgency:
+   - **high**: Critical, blocking, or high business value
+   - **medium**: Important but not urgent, moderate impact
+   - **low**: Nice to have, minor improvements
+
+4. **Scope and Complexity Analysis**: Determine if the task is appropriately sized and scoped
+
+If you recommend changes to type or priority, include them at the top of your response:
+**Type**: [recommended type with brief reasoning]
+**Priority**: [recommended priority with brief reasoning]
+
+### Expected Content Format:
+
+#### Description
+[Provide a clear, detailed description of what needs to be accomplished]
+
+#### Acceptance Criteria
+- [ ] [Specific, testable criterion 1]
+- [ ] [Specific, testable criterion 2]
+- [ ] [Specific, testable criterion 3]
+[Add more as needed]
+
+#### Technical Details
+[Include implementation considerations, architecture notes, dependencies, etc.]
+
+#### Implementation Notes
+[Any specific guidance, patterns to follow, potential challenges, etc.]
+[Split into smaller tasks and todo items if needed]
+
+## Advanced Improvement Guidelines:
+
+1. **Precision & Clarity**: Transform vague requirements into concrete, measurable, actionable items with clear success criteria
+2. **Technical Depth**: Consider implementation complexity, architecture implications, and technical dependencies
+3. **Project Alignment**: Ensure the task fits within the existing codebase architecture and follows established patterns
+4. **Quality Assurance**: Include comprehensive testing strategies, edge cases, and validation approaches
+5. **Risk Assessment**: Identify potential challenges, blockers, and mitigation strategies
+6. **Cross-functional Impact**: Consider effects on other systems, teams, or user experiences
+7. **Scalability & Performance**: Include considerations for performance, scalability, and maintainability
+8. **Documentation**: Ensure adequate documentation and knowledge transfer requirements
+9. **Scope Optimization**: Balance completeness with manageable task size for effective execution
+10. **Context Preservation**: Maintain original intent while significantly enhancing detail and clarity
+11. **Standards Compliance**: Follow GitHub Flavored Markdown specification and project conventions
+12. **Asset Preservation**: Retain any images, diagrams, or other media from the original content
+13. **Simple and focus**: Keep the task simple, don't make it too complex and over design, focus on the core functionality and core business logic
+
+## Expected Output Structure
+
+Return a JSON object with:
+- "type": one of [feature, bug, chore, refactor, test, doc]
+- "priority": one of [high, medium, low]
+- "content": the improved task specification in markdown format with proper JSON escaping
+
+## Project Context
+
+<ProjectContext>
+{{projectContext}}
+</ProjectContext>
+
+## Current Task Details
+- **ID:** {{taskId}}
+-  **Title:** {{taskTitle}}
+-  **Type:** {{taskType}}
+-  **Priority:** {{taskPriority}}
+-  **Status:** {{taskStatus}}
+
+## Content to Improve
+
+<CurrentTaskContent>
+{{taskContent}}
+</CurrentTaskContent>
+`;
+const TASK_TEMPLATE = `## Task Assignment
+
+Deliver the following task.
+
+## Responsibilities
+
+1. **Analyze requirements** — study the acceptance criteria to clarify what must be delivered.
+2. **Review the codebase** — understand the current implementation, architecture, and coding patterns.
+3. **Implement changes** — add or modify code according to project conventions.
+4. **Test thoroughly** — write/run tests and verify that all builds succeed.
+5. **Update the task file** — tick off each acceptance criterion that you have completed.
+
+## Development Guidelines
+
+- Respect existing architecture and style conventions.
+- Add robust error handling.
+- Update documentation when necessary.
+- Ensure all tests pass and the project builds cleanly.
+- Commit with a clear, descriptive message.
+- Create todo list to track the progress.
+
+## Expected Deliverables
+
+- A working implementation that satisfies every requirement.
+- An updated task file showing completed acceptance criteria.
+- Clean, well-documented code.
+- Passing build and test results.
+
+Begin by examining the codebase; then proceed with the implementation.
+
+---
+
+### Task Snapshot
+
+- **ID:** {{taskId}}
+- **Title:** {{taskTitle}}
+- **Type:** {{taskType}}
+- **Priority:** {{taskPriority}}
+- **Status:** {{taskStatus}}
+- **Tags:** {{tagsList}}
+
+#### Description
+
+{{taskContent}}
+
+`;
+const MERGE_TEMPLATE = `Goal: Merge feature branch into base without pushing to remote. Resolve conflicts safely.
+
+Context:
+
+- Repo: {{repoPath}}
+- Worktree: {{worktreePath}}
+- Feature branch: {{featureBranch}}
+- Base branch: {{baseBranch}}
+
+If conflicts:
+
+- Prefer {{featureBranch}} when changes are clearly additive or isolated.
+- Keep {{baseBranch}} when it contains newer logic that would be overwritten.
+- Integrate both sides when needed.
+- After each file: git add <file>
+`;
+const REVIEW_TEMPLATE = `## Code Review Task
+
+Review the changes made for this task comprehensively.
+
+1. **Analyze the implemented changes** by examining the modified files, some of them might be committed in the recent commits
+2. **Evaluate code quality** including:
+  - Code structure and organization
+  - Adherence to coding standards and conventions
+  - Error handling and edge cases
+  - Performance considerations
+  - Security implications
+  - Test coverage and quality
+
+3. **Verify task completion** by checking that:
+  - All acceptance criteria are met
+  - Implementation matches the task requirements
+  - No unrelated changes were introduced
+
+4. **Provide structured feedback** using this JSON structure:
+
+{
+  "reviewSummary": "Brief overview of the implementation and overall assessment",
+  "recommendations": [
+    "Specific recommendation 1",
+    "Specific recommendation 2",
+    "Specific recommendation 3"
+  ],
+  "qualityScore": 85
+}
+
+## Review Guidelines
+
+- Quality Score: Provide a score from 0-100 (higher is better), below 70 will trigger a re-implementation with your advice.
+- Recommendations: Provide actionable, specific improvements
+- Focus Areas: Security, performance, maintainability, testing, documentation
+- Scoring Rubric (0-100):
+  - Correctness & completeness: 0-35
+  - Code quality & maintainability: 0-30
+  - Testing & coverage: 0-20
+  - Security & performance considerations: 0-15
+
+If you identify any critical bugs or potential improvements, provide detailed notes, accpetance criteria, implementation details, todo list, etc. in the Recommendations section and return a score below 70. This will trigger a reimplementation based on your feedback.
+
+---
+
+## Task Context
+
+- **ID:** {{taskId}}
+- **Title:** {{taskTitle}}
+- **Type:** {{taskType}}
+- **Priority:** {{taskPriority}}
+
+## Task Description
+
+{{taskContent}}
+
+## Review Context
+
+- **Worktree Path:** {{worktreePath}}
+- **Branch:** {{worktreeBranch}}
+- **Status:** active
+
+{{additionalContext}}
+`;
+// Quality checks detection prompt (AI-only, JSON strict)
+const DETECT_QUALITY_CHECKS_TEMPLATE = `You are analyzing a code repository to determine fast, local quality checks.
+
+Constraints:
+- Prefer fast checks suitable for local iteration.
+- Only output valid JSON. No prose. No markdown. Do not include comments.
+- Schema: { "checks": [ { "name": string, "command": string, "args": string[], "timeout": number, "enabled": boolean } ] }
+- The unit of timeout is milliseconds.
+- Defaults: enable tests/lint/typecheck if present; set build enabled=false unless explicitly required.
+- Use the working directory tools (glob/grep/read) to discover project configuration.
+
+Examples by ecosystem:
+- Node: scripts in package.json (test, lint, typecheck). Use package manager scripts (npm run, pnpm, yarn) if detectable.
+- Python: pytest, ruff, mypy if config present.
+- Rust: cargo check/test/fmt/clippy if available.
+- Go: go test, go vet, golangci-lint if configured.
+- Others: propose similar fast checks when clear; otherwise return an empty list.
+
+Return strictly the JSON with the schema above.`;
+// -----------------------------
+// Simple string template engine
+// -----------------------------
+function escapeRegExp(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function render(template, vars) {
+    let out = template;
+    for (const [key, value] of Object.entries(vars)) {
+        const re = new RegExp(`{{\\s*${escapeRegExp(key)}\\s*}}`, 'g');
+        out = out.replace(re, value ?? '');
+    }
+    // Remove any unreplaced placeholders
+    return out.replace(/{{\s*[^}]+\s*}}/g, '');
+}
+// PromptService centralizes prompt generation logic used by AgentService.
+// Prompts are hard-coded templates for now, with light project context reads.
+export class PromptService {
+    constructor(projectRoot, taskService) {
+        this.projectRoot = projectRoot;
+        this.taskService = taskService;
+    }
+    async generateImprovementPrompt(task, taskData) {
+        // Read project context
+        const productOverviewPath = path.join(getVibeDir(), 'product_overview.md');
+        let productContext = '';
+        try {
+            productContext = await fs.readFile(productOverviewPath, 'utf-8');
+        }
+        catch {
+            log.warn('Could not read product_overview.md for improvement prompt', undefined, 'prompt-service');
+        }
+        return render(IMPROVEMENT_TEMPLATE, {
+            projectContext: productContext,
+            taskId: task.id,
+            taskTitle: taskData.title,
+            taskType: taskData.type,
+            taskPriority: taskData.priority,
+            taskStatus: task.status,
+            taskContent: taskData.content,
+        });
+    }
+    async generateTaskPrompt(task) {
+        const tagsList = task.tags.join(', ');
+        return render(TASK_TEMPLATE, {
+            taskId: task.id,
+            taskTitle: task.title,
+            taskType: task.type,
+            taskPriority: task.priority,
+            taskStatus: task.status,
+            taskContent: task.content,
+            tagsList,
+        });
+    }
+    async generateAIMergePrompt(task, worktree, baseBranch) {
+        const repoPath = this.projectRoot;
+        const featureBr = worktree.branchName;
+        // Determine base branch: prefer provided, otherwise current branch in repo root, fallback to 'main'
+        let baseBr = baseBranch?.trim();
+        if (!baseBr) {
+            try {
+                const { spawn } = await import('child_process');
+                baseBr = await new Promise((resolve, reject) => {
+                    const child = spawn('git', ['branch', '--show-current'], {
+                        cwd: repoPath,
+                        stdio: ['ignore', 'pipe', 'pipe'],
+                    });
+                    let out = '';
+                    child.stdout?.on('data', (d) => (out += d.toString()));
+                    child.on('close', () => resolve(out.trim() || 'main'));
+                    child.on('error', reject);
+                });
+            }
+            catch {
+                baseBr = 'main';
+            }
+        }
+        return render(MERGE_TEMPLATE, {
+            repoPath,
+            worktreePath: worktree.path,
+            featureBranch: featureBr,
+            baseBranch: baseBr,
+        });
+    }
+    async generateReviewPrompt(task, worktree, reviewContext) {
+        const additionalContext = reviewContext ? `\n**Additional Context:** ${reviewContext}` : '';
+        return render(REVIEW_TEMPLATE, {
+            taskId: task.id,
+            taskTitle: task.title,
+            taskType: task.type,
+            taskPriority: task.priority,
+            taskContent: task.content,
+            worktreePath: worktree.path,
+            worktreeBranch: worktree.branchName,
+            additionalContext,
+        });
+    }
+}
+// Utility export for building the quality checks detection prompt
+export function getQualityChecksDetectionPrompt() {
+    return DETECT_QUALITY_CHECKS_TEMPLATE;
+}

package/dist/runtime/api/agent/routing-policy.d.ts

@@ -0,0 +1,188 @@
+/**
+ * AI Routing Policy Management
+ * Handles provider selection per operation with fallbacks and configuration
+ */
+import { z } from 'zod';
+/**
+ * Operation types that support AI routing
+ */
+export type RoutableOperation = 'execute_task' | 'improve_task' | 'ai_codereview' | 'ai_merge';
+/**
+ * Generation options for AI execution
+ */
+export declare const GenerationOptionsSchema: z.ZodObject<{
+    temperature: z.ZodOptional<z.ZodNumber>;
+    maxTokens: z.ZodOptional<z.ZodNumber>;
+    tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    maxTokens?: number | undefined;
+    tools?: string[] | undefined;
+    temperature?: number | undefined;
+}, {
+    maxTokens?: number | undefined;
+    tools?: string[] | undefined;
+    temperature?: number | undefined;
+}>;
+export type GenerationOptions = z.infer<typeof GenerationOptionsSchema>;
+/**
+ * Per-operation routing configuration
+ */
+export declare const OperationConfigSchema: z.ZodObject<{
+    provider: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    options: z.ZodOptional<z.ZodObject<{
+        temperature: z.ZodOptional<z.ZodNumber>;
+        maxTokens: z.ZodOptional<z.ZodNumber>;
+        tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        maxTokens?: number | undefined;
+        tools?: string[] | undefined;
+        temperature?: number | undefined;
+    }, {
+        maxTokens?: number | undefined;
+        tools?: string[] | undefined;
+        temperature?: number | undefined;
+    }>>;
+    fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    provider: string;
+    options?: {
+        maxTokens?: number | undefined;
+        tools?: string[] | undefined;
+        temperature?: number | undefined;
+    } | undefined;
+    model?: string | undefined;
+    fallback?: string[] | undefined;
+}, {
+    provider: string;
+    options?: {
+        maxTokens?: number | undefined;
+        tools?: string[] | undefined;
+        temperature?: number | undefined;
+    } | undefined;
+    model?: string | undefined;
+    fallback?: string[] | undefined;
+}>;
+export type OperationConfig = z.infer<typeof OperationConfigSchema>;
+/**
+ * Complete routing policy schema
+ */
+export declare const RoutingPolicySchema: z.ZodObject<{
+    defaultProvider: z.ZodString;
+    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "improve_task", "ai_codereview", "ai_merge"]>, z.ZodObject<{
+        provider: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+        options: z.ZodOptional<z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            maxTokens: z.ZodOptional<z.ZodNumber>;
+            tools: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+        }, "strip", z.ZodTypeAny, {
+            maxTokens?: number | undefined;
+            tools?: string[] | undefined;
+            temperature?: number | undefined;
+        }, {
+            maxTokens?: number | undefined;
+            tools?: string[] | undefined;
+            temperature?: number | undefined;
+        }>>;
+        fallback: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        provider: string;
+        options?: {
+            maxTokens?: number | undefined;
+            tools?: string[] | undefined;
+            temperature?: number | undefined;
+        } | undefined;
+        model?: string | undefined;
+        fallback?: string[] | undefined;
+    }, {
+        provider: string;
+        options?: {
+            maxTokens?: number | undefined;
+            tools?: string[] | undefined;
+            temperature?: number | undefined;
+        } | undefined;
+        model?: string | undefined;
+        fallback?: string[] | undefined;
+    }>>>;
+}, "strip", z.ZodTypeAny, {
+    defaultProvider: string;
+    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_codereview" | "ai_merge", {
+        provider: string;
+        options?: {
+            maxTokens?: number | undefined;
+            tools?: string[] | undefined;
+            temperature?: number | undefined;
+        } | undefined;
+        model?: string | undefined;
+        fallback?: string[] | undefined;
+    }>> | undefined;
+}, {
+    defaultProvider: string;
+    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_codereview" | "ai_merge", {
+        provider: string;
+        options?: {
+            maxTokens?: number | undefined;
+            tools?: string[] | undefined;
+            temperature?: number | undefined;
+        } | undefined;
+        model?: string | undefined;
+        fallback?: string[] | undefined;
+    }>> | undefined;
+}>;
+export type RoutingPolicy = z.infer<typeof RoutingPolicySchema>;
+/**
+ * Resolved provider configuration for execution
+ */
+export interface ResolvedProvider {
+    provider: string;
+    model?: string;
+    options?: GenerationOptions;
+    fallbacks?: string[];
+}
+/**
+ * Routing Policy Manager
+ * Manages AI provider routing policies with hot-reload capability
+ */
+export declare class RoutingPolicyManager {
+    private policy;
+    private policyFilePath;
+    private lastModified;
+    constructor();
+    /**
+     * Get current effective policy with hot-reload
+     */
+    getPolicy(): Promise<RoutingPolicy>;
+    /**
+     * Update routing policy and persist to disk
+     */
+    updatePolicy(updates: Partial<RoutingPolicy>): Promise<void>;
+    /**
+     * Resolve provider for a specific operation
+     */
+    resolveProviderForOperation(operation: RoutableOperation, overrides?: Partial<ResolvedProvider>): Promise<ResolvedProvider>;
+    /**
+     * Set default provider
+     */
+    setDefaultProvider(provider: string): Promise<void>;
+    /**
+     * Set operation-specific routing
+     */
+    setOperationConfig(operation: RoutableOperation, config: OperationConfig): Promise<void>;
+    /**
+     * Validate policy against available providers
+     */
+    validatePolicy(policy: RoutingPolicy, availableProviders: Set<string>): string[];
+    /**
+     * Load policy from file if it has changed
+     */
+    private loadPolicyIfChanged;
+    /**
+     * Create example policy file if it doesn't exist
+     */
+    createExamplePolicy(): Promise<void>;
+    /**
+     * Get policy file path for external access
+     */
+    getPolicyFilePath(): string;
+}