vibeman 0.0.2 → 0.0.5

package/dist/runtime/api/agent/codex-cli-provider.test.js

@@ -24,16 +24,18 @@ describe('CodexCliProvider (mocked)', () => {
                     setTimeout(() => proc.emit('exit', 0, null), 20);
                     return proc;
                 },
+                exec: vi.fn(),
+                execFile: vi.fn(),
             };
         });
         const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
-        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000 });
+        const provider = new CodexCliProvider({ defaultTimeoutMs: 1000, codexBinPath: 'codex' });
         const messages = [];
         const iter = provider.execute('What is this project about?', {
             workingDirectory: process.cwd(),
             images: ['a.png', 'b.jpg'],
             effort: 'minimal',
-            model: 'gpt-5',
+            model: 'gpt-5.2',
         });
         for await (const m of iter)
             messages.push(m);
@@ -53,7 +55,48 @@ describe('CodexCliProvider (mocked)', () => {
         expect(captured[1]).toContain('a.png,b.jpg');
         const modelIdx = captured[1].indexOf('--model');
         expect(modelIdx).toBeGreaterThan(-1);
-        expect(captured[1][modelIdx + 1]).toBe('gpt-5');
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5.2');
+        const configIdx = captured[1].indexOf('-c');
+        expect(configIdx).toBeGreaterThan(-1);
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=low');
+    });
+    it('maps reasoning level encoded in model name to CLI flags', async () => {
+        vi.resetModules();
+        vi.doMock('child_process', () => {
+            let captured = [];
+            return {
+                __captured: () => captured,
+                spawn: (cmd, args, opts) => {
+                    captured = [cmd, args, opts];
+                    const { EventEmitter } = require('events');
+                    const stdout = new EventEmitter();
+                    const proc = new EventEmitter();
+                    proc.stdout = stdout;
+                    setTimeout(() => stdout.emit('data', Buffer.from('Reasoned\n')), 10);
+                    setTimeout(() => proc.emit('exit', 0, null), 20);
+                    return proc;
+                },
+                exec: vi.fn(),
+                execFile: vi.fn(),
+            };
+        });
+        const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
+        const provider = new CodexCliProvider({ codexBinPath: 'codex' });
+        const messages = [];
+        const iter = provider.execute('Solve with depth', {
+            workingDirectory: process.cwd(),
+            model: 'gpt-5.1-codex-max-extra-high',
+        });
+        for await (const m of iter)
+            messages.push(m);
+        const mockSpawn = await import('child_process');
+        const captured = mockSpawn.__captured();
+        const modelIdx = captured[1].indexOf('--model');
+        expect(modelIdx).toBeGreaterThan(-1);
+        expect(captured[1][modelIdx + 1]).toBe('gpt-5.1-codex-max');
+        const configIdx = captured[1].indexOf('-c');
+        expect(configIdx).toBeGreaterThan(-1);
+        expect(captured[1][configIdx + 1]).toBe('model_reasoning_effort=extra_high');
     });
     it('prepends system prompts and toggles sandbox bypass flag', async () => {
         vi.resetModules();
@@ -71,10 +114,12 @@ describe('CodexCliProvider (mocked)', () => {
                     setTimeout(() => proc.emit('exit', 0, null), 10);
                     return proc;
                 },
+                exec: vi.fn(),
+                execFile: vi.fn(),
             };
         });
         const { CodexCliProvider } = await import('./ai-providers/codex-cli-provider.js');
-        const provider = new CodexCliProvider();
+        const provider = new CodexCliProvider({ codexBinPath: 'codex' });
         const iter = provider.execute('Implement feature', {
             workingDirectory: '/tmp/project',
             systemPrompt: 'Base system prompt',
@@ -88,9 +133,11 @@ describe('CodexCliProvider (mocked)', () => {
         const captured = mockSpawn.__captured();
         expect(captured[1][1]).toContain('Base system prompt');
         expect(captured[1][1]).toContain('Additional guidance');
-        const bypassIdx = captured[1].indexOf('--dangerously-bypass-approvals-and-sandbox');
-        expect(bypassIdx).toBeGreaterThan(-1);
-        expect(captured[1][bypassIdx + 1]).toBeUndefined();
+        const fullAutoIdx = captured[1].indexOf('--full-auto');
+        expect(fullAutoIdx).toBeGreaterThan(-1);
+        const sandboxIdx = captured[1].indexOf('--sandbox');
+        expect(sandboxIdx).toBeGreaterThan(-1);
+        expect(captured[1][sandboxIdx + 1]).toBe('danger-full-access');
     });
 });
 // Real integration (opt-in)

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

@@ -1,79 +1,60 @@
 import path from 'path';
 import fs from 'fs/promises';
 import { log } from '../lib/logger.js';
-import { getVibeDir } from '../lib/server/project-root.js';
+import { getProjectRoot, 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.
+const IMPROVEMENT_TEMPLATE = `Streamline the task spec below so it is easy to execute and maintain.
 
-## Analysis Framework
+## Guidance
 
-First, conduct a thorough analysis:
+- **IMPORTANT: Detect the language of the task content provided and respond in that SAME language for all markdown sections.** Keep enum fields (type, priority) in English, but write all descriptive content (Description, Technical Details, Implementation Notes, etc.) in the detected language.
+- Judge complexity first: keep the spec compact when the work is straightforward; elaborate only when multiple systems or risks require extra direction.
+- Drop low-value detail (exact file names, functions, or boilerplate such as "run tests").
+- Keep every section action-focused and only include information that will change how the work is done.
 
-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
+If type or priority should change, surface the recommendation before the content:
+**Type**: [new type with a brief reason, omit if unchanged]
+**Priority**: [new priority with a brief reason, omit if unchanged]
 
-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
+## Response Format
 
-4. **Scope and Complexity Analysis**: Determine if the task is appropriately sized and scoped
+Return JSON with:
+- "type": feature | bug | chore | refactor | test | doc
+- "priority": high | medium | low
+- "title": optional concise title
+- "content": markdown that follows the layout below (omit a leading H1 when a title is provided)
 
-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]
+## Markdown Layout
 
-### Expected Content Format:
+Use clear, economical language in this order.
 
-#### Description
-[Provide a clear, detailed description of what needs to be accomplished]
+<TaskContentTemplate>
 
-#### Acceptance Criteria
-- [ ] [Specific, testable criterion 1]
-- [ ] [Specific, testable criterion 2]
-- [ ] [Specific, testable criterion 3]
-[Add more as needed]
+## Description
+[Outcome in plain language. Keep it short when the task is simple.]
+## Technical Details
+[Only the essential constraints, integrations, or dependencies.]
 
-#### Technical Details
-[Include implementation considerations, architecture notes, dependencies, etc.]
+## Implementation Notes
+[Key tactics, risks, or decisions to highlight.]
 
-#### Implementation Notes
-[Any specific guidance, patterns to follow, potential challenges, etc.]
-[Split into smaller tasks and todo items if needed]
+## Recommended Steps
+- Step 1
+  - [ ] TODO
+  - [ ] TODO
+- Step 2
+  - [ ] TODO
+(Provide 2-5 steps total, each with 1-3 TODO checkboxes.)
 
-## Advanced Improvement Guidelines:
+## Acceptance Criteria
+- [ ] Concise, verifiable results. Keep the list short but complete.
 
-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
+## Implementation Summary
+[Brief, auto-generated summary of changes.]
 
-## Expected Output Structure
-
-Return a JSON object with:
-- "type": one of [feature, bug, chore, refactor, test, doc]
-- "priority": one of [high, medium, low]
-- "title": a concise, descriptive title for the task (optional, but preferred)
-- "content": the improved task specification in markdown format with proper JSON escaping
-
-If you include a title in the JSON response, do NOT include an H1 heading at the beginning of the content field to avoid duplication.
+</TaskContentTemplate>
 
 ## Project Context
 
@@ -81,12 +62,13 @@ If you include a title in the JSON response, do NOT include an H1 heading at the
 {{projectContext}}
 </ProjectContext>
 
-## Current Task Details
+## Current Task
+
 - **ID:** {{taskId}}
--  **Title:** {{taskTitle}}
--  **Type:** {{taskType}}
--  **Priority:** {{taskPriority}}
--  **Status:** {{taskStatus}}
+- **Title:** {{taskTitle}}
+- **Type:** {{taskType}}
+- **Priority:** {{taskPriority}}
+- **Status:** {{taskStatus}}
 
 ## Content to Improve
 
@@ -94,43 +76,24 @@ If you include a title in the JSON response, do NOT include an H1 heading at the
 {{taskContent}}
 </CurrentTaskContent>
 `;
-const TASK_TEMPLATE = `## Task Assignment
+const TASK_TEMPLATE = `## Task Brief
 
-Deliver the following task.
+Deliver the task by following the specification exactly as written.
 
 ## Workflow Instructions
 
 {{workflowInstructions}}
 
-## Responsibilities
+## How to Work
 
-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.
-
----
+- Start with the **Description** to internalize the expected outcome.
+- Apply every constraint under **Technical Details**.
+- Review **Implementation Notes** for callouts, risks, or decisions you must honor.
+- Work through each group in **Recommended Steps**, checking off the TODO boxes inside the task file as you complete them.
+- Do not mark the task complete until every **Acceptance Criterion** is satisfied and verified.
+- Think independently and do not just rely on the task file to guide your work. You can update the task file as you work.
 
-### Task Snapshot
+## Task Reference
 
 - **ID:** {{taskId}}
 - **Title:** {{taskTitle}}
@@ -138,29 +101,58 @@ Begin by examining the codebase; then proceed with the implementation.
 - **Priority:** {{taskPriority}}
 - **Status:** {{taskStatus}}
 - **Tags:** {{tagsList}}
-
 {{taskFilePathInfo}}
 
-#### Description
+## Task Specification
 
 {{taskContent}}
 
 `;
-const MERGE_TEMPLATE = `Goal: Merge feature branch into base without pushing to remote. Resolve conflicts safely.
+const MERGE_TEMPLATE = `Goal: Merge feature branch into base branch in the main repo. Do NOT push to remote.
 
-Context:
+## Context
 
-- Repo: {{repoPath}}
+- Main Repo: {{repoPath}}
 - Worktree: {{worktreePath}}
 - Feature branch: {{featureBranch}}
 - Base branch: {{baseBranch}}
 
-If conflicts:
+## CRITICAL INSTRUCTIONS
+
+1. **Do NOT run formatters, linters, or builds**
+2. **Always use \`--no-verify\` flag** to skip pre-commit hooks
+3. **Handle any uncommitted changes in main repo first**
+
+## Steps
+
+\`\`\`bash
+cd {{repoPath}}
+
+# Step 1: Stash any uncommitted changes in main repo
+git stash --include-untracked || true
+
+# Step 2: Checkout base branch and update
+git checkout {{baseBranch}}
+git fetch origin {{baseBranch}}
+git reset --hard origin/{{baseBranch}}
+
+# Step 3: Merge feature branch into base
+git merge {{featureBranch}} --no-ff --no-verify -m "Merge branch '{{featureBranch}}' into {{baseBranch}}"
 
-- 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>
+# Step 4: Restore stashed changes if any
+git stash pop || true
+\`\`\`
+
+If conflicts occur during merge:
+- Prefer {{featureBranch}} when changes are clearly additive
+- Keep {{baseBranch}} when it contains newer logic
+- After resolving: \`git add <file>\` then \`git commit --no-verify\`
+
+## Output Format
+
+At the end, output exactly one of:
+- MERGE_STATUS: SUCCESS
+- MERGE_STATUS: FAILED
 `;
 const REVIEW_TEMPLATE = `## Code Review Task
 
@@ -295,20 +287,31 @@ export class PromptService {
     }
     async generateImprovementPrompt(task, taskData) {
         // Read project context
-        const productOverviewPath = path.join(getVibeDir(), 'product_overview.md');
-        let productContext = '';
+        const contextSections = [];
+        const vibeDir = getVibeDir();
+        const productOverviewPath = path.join(vibeDir, 'product_overview.md');
+        try {
+            await fs.access(productOverviewPath, fs.constants.F_OK);
+            contextSections.push(`**Product overview file:** ${productOverviewPath}\nReference this for additional product context.`);
+        }
+        catch {
+            log.warn('Could not read product_overview.md for improvement prompt, something went wrong with initialization', undefined, 'prompt-service');
+        }
+        const readmePath = path.join(getProjectRoot(), 'README.md');
         try {
-            productContext = await fs.readFile(productOverviewPath, 'utf-8');
+            await fs.access(readmePath, fs.constants.F_OK);
+            contextSections.push(`**Repository README:** ${readmePath}\nReview this if you need additional project context.`);
         }
         catch {
-            log.warn('Could not read product_overview.md for improvement prompt', undefined, 'prompt-service');
+            log.info('README.md not found when building improvement prompt context', { readmePath }, 'prompt-service');
         }
         // Add task file path to project context for improvement prompts
         const taskFilePath = this.generateTaskFilePath(task.id);
         if (taskFilePath && (await this.validateTaskFile(taskFilePath))) {
-            productContext += `\n\n**Current task file location:** ${taskFilePath}`;
+            contextSections.push(`**Current task file location:** ${taskFilePath}`);
             log.info(`Task file path included in improvement prompt`, { taskId: task.id, path: taskFilePath }, 'prompt-service');
         }
+        const productContext = contextSections.join('\n\n');
         return render(IMPROVEMENT_TEMPLATE, {
             projectContext: productContext,
             taskId: task.id,

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

@@ -131,14 +131,49 @@ Test task content`;
                 priority: 'high',
                 content: 'Improved content',
             };
+            const productOverviewPath = path.join(TEST_DATA_DIR, 'product_overview.md');
+            const readmePath = path.join(TEST_DATA_DIR, 'README.md');
+            await fs.writeFile(productOverviewPath, 'Existing product overview content for context.', 'utf-8');
+            await fs.writeFile(readmePath, '# Workspace README\n', 'utf-8');
             // Create task file
             const taskFilePath = path.join(TEST_TASKS_DIR, 'IMPROVE-TASK-001.md');
             await fs.writeFile(taskFilePath, 'Task file content', 'utf-8');
             const prompt = await promptService.generateImprovementPrompt(mockTask, taskData);
+            expect(prompt).not.toContain('Existing product overview content for context.');
+            expect(prompt).toContain(`**Product overview file:** ${productOverviewPath}`);
+            expect(prompt).toContain('Reference this for additional product context.');
+            expect(prompt).toContain(`**Repository README:** ${readmePath}`);
+            expect(prompt).toContain('Review this if you need additional project context.');
             expect(prompt).toContain('Current task file location:');
             expect(prompt).toContain(taskFilePath);
             expect(prompt).toContain('IMPROVE-TASK-001');
         });
+        it('should include language preservation instructions in the prompt', async () => {
+            const mockTask = {
+                id: 'LANG-TEST-001',
+                title: 'Language Test Task',
+                type: 'feature',
+                status: 'backlog',
+                priority: 'medium',
+                tags: [],
+                content: 'Test content in any language',
+                created_at: '2024-09-04T12:00:00.000Z',
+                updated_at: '2024-09-04T12:00:00.000Z',
+                assignee: [],
+                comments: [],
+            };
+            const taskData = {
+                title: 'Tarea de prueba de idioma',
+                type: 'feature',
+                priority: 'high',
+                content: 'Contenido de prueba en español',
+            };
+            const prompt = await promptService.generateImprovementPrompt(mockTask, taskData);
+            // Verify the prompt contains language preservation instructions
+            expect(prompt).toContain('Detect the language of the task content');
+            expect(prompt).toContain('respond in that SAME language');
+            expect(prompt).toContain('Keep enum fields (type, priority) in English');
+        });
     });
     describe('generateReviewPrompt', () => {
         it('should include task file path in additional context', async () => {

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

@@ -6,7 +6,8 @@ import { z } from 'zod';
 /**
  * Operation types that support AI routing
  */
-export type RoutableOperation = 'execute_task' | 'improve_task' | 'ai_codereview' | 'ai_merge';
+declare const ROUTABLE_OPERATIONS: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
+export type RoutableOperation = (typeof ROUTABLE_OPERATIONS)[number];
 /**
  * Generation options for AI execution
  */
@@ -69,7 +70,7 @@ export type OperationConfig = z.infer<typeof OperationConfigSchema>;
  */
 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<{
+    operations: z.ZodOptional<z.ZodRecord<z.ZodEnum<["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"]>, z.ZodObject<{
         provider: z.ZodString;
         model: z.ZodOptional<z.ZodString>;
         options: z.ZodOptional<z.ZodObject<{
@@ -107,7 +108,7 @@ export declare const RoutingPolicySchema: z.ZodObject<{
     }>>>;
 }, "strip", z.ZodTypeAny, {
     defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+    operations?: Partial<Record<"execute_task" | "quality_checks" | "ai_codereview" | "ai_merge" | "improve_task", {
         provider: string;
         options?: {
             temperature?: number | undefined;
@@ -119,7 +120,7 @@ export declare const RoutingPolicySchema: z.ZodObject<{
     }>> | undefined;
 }, {
     defaultProvider: string;
-    operations?: Partial<Record<"execute_task" | "improve_task" | "ai_merge" | "ai_codereview", {
+    operations?: Partial<Record<"execute_task" | "quality_checks" | "ai_codereview" | "ai_merge" | "improve_task", {
         provider: string;
         options?: {
             temperature?: number | undefined;
@@ -131,6 +132,7 @@ export declare const RoutingPolicySchema: z.ZodObject<{
     }>> | undefined;
 }>;
 export type RoutingPolicy = z.infer<typeof RoutingPolicySchema>;
+export declare const ROUTABLE_OPERATION_LIST: readonly ["execute_task", "quality_checks", "ai_codereview", "ai_merge", "improve_task"];
 /**
  * Resolved provider configuration for execution
  */
@@ -142,47 +144,28 @@ export interface ResolvedProvider {
 }
 /**
  * Routing Policy Manager
- * Manages AI provider routing policies with hot-reload capability
+ * Manages AI provider routing policies stored inside settings.json
  */
 export declare class RoutingPolicyManager {
     private policy;
-    private policyFilePath;
-    private lastModified;
+    private readonly settingsService;
     constructor();
     /**
-     * Get current effective policy with hot-reload
+     * Get current effective policy (lazy loads from settings)
      */
     getPolicy(): Promise<RoutingPolicy>;
     /**
-     * Update routing policy and persist to disk
+     * Update routing policy and persist via settings service
      */
     updatePolicy(updates: Partial<RoutingPolicy>): Promise<void>;
     /**
      * Resolve provider for a specific operation
      */
+    getEffectivePolicy(): Promise<RoutingPolicy>;
     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;
+    private buildPolicyFromSettings;
 }
+export {};