@agile-vibe-coding/avc 0.1.0 → 0.1.1

package/cli/template-processor.js

@@ -2,7 +2,7 @@ import dotenv from 'dotenv';
 import fs from 'fs';
 import path from 'path';
 import readline from 'readline';
-import Anthropic from '@anthropic-ai/sdk';
+import { LLMProvider } from './llm-provider.js';
 import { fileURLToPath } from 'url';
 
 const __filename = fileURLToPath(import.meta.url);
@@ -20,7 +20,7 @@ const __dirname = path.dirname(__filename);
  * 6. Write to .avc/project/doc.md
  */
 class TemplateProcessor {
-  constructor(progressPath = null) {
+  constructor(progressPath = null, nonInteractive = false) {
     // Load environment variables from project .env
     dotenv.config({ path: path.join(process.cwd(), '.env') });
 
@@ -29,11 +29,13 @@ class TemplateProcessor {
     this.outputPath = path.join(this.outputDir, 'doc.md');
     this.avcConfigPath = path.join(process.cwd(), '.avc/avc.json');
     this.progressPath = progressPath;
+    this.nonInteractive = nonInteractive;
 
     // Read model configuration from avc.json
-    this.model = this.readModelConfig();
-    this.apiKey = process.env.ANTHROPIC_API_KEY;
-    this.claudeClient = null;
+    const { provider, model } = this.readModelConfig();
+    this._providerName = provider;
+    this._modelName = model;
+    this.llmProvider = null;
   }
 
   /**
@@ -42,10 +44,73 @@ class TemplateProcessor {
   readModelConfig() {
     try {
       const config = JSON.parse(fs.readFileSync(this.avcConfigPath, 'utf8'));
-      return config.settings?.model || 'claude-sonnet-4-5-20250929';
+      const ceremony = config.settings?.ceremonies?.[0];
+      if (ceremony) {
+        return { provider: ceremony.provider || 'claude', model: ceremony.defaultModel || 'claude-sonnet-4-5-20250929' };
+      }
+      // Legacy fallback: settings.model without ceremonies array
+      return { provider: 'claude', model: config.settings?.model || 'claude-sonnet-4-5-20250929' };
     } catch (error) {
       console.warn('⚠️  Could not read model config, using default');
-      return 'claude-sonnet-4-5-20250929';
+      return { provider: 'claude', model: 'claude-sonnet-4-5-20250929' };
+    }
+  }
+
+  /**
+   * Read guidelines from avc.json ceremony configuration
+   */
+  readGuidelines() {
+    try {
+      const config = JSON.parse(fs.readFileSync(this.avcConfigPath, 'utf8'));
+      const ceremony = config.settings?.ceremonies?.[0];
+      return ceremony?.guidelines || {};
+    } catch (error) {
+      return {};
+    }
+  }
+
+  /**
+   * Load agent instructions from markdown file
+   * @param {string} agentFileName - Filename in src/cli/agents/
+   * @returns {string|null} - Agent instructions content or null if not found
+   */
+  loadAgentInstructions(agentFileName) {
+    try {
+      const agentPath = path.join(__dirname, 'agents', agentFileName);
+      if (!fs.existsSync(agentPath)) {
+        console.warn(`⚠️  Agent instruction file not found: ${agentFileName}`);
+        return null;
+      }
+      return fs.readFileSync(agentPath, 'utf8');
+    } catch (error) {
+      console.warn(`⚠️  Could not load agent instructions: ${error.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * Get agent instructions for a specific ceremony stage
+   * @param {string} stage - Ceremony stage (e.g., 'enhancement', 'suggestion', 'validation')
+   * @returns {string|null} - Agent instructions or null if not configured/found
+   */
+  getAgentForStage(stage) {
+    try {
+      const config = JSON.parse(fs.readFileSync(this.avcConfigPath, 'utf8'));
+      const ceremony = config.settings?.ceremonies?.[0];
+
+      if (!ceremony?.agents || ceremony.agents.length === 0) {
+        return null;
+      }
+
+      const agent = ceremony.agents.find(a => a.stage === stage);
+      if (!agent) {
+        return null;
+      }
+
+      return this.loadAgentInstructions(agent.instruction);
+    } catch (error) {
+      console.warn(`⚠️  Could not get agent for stage ${stage}: ${error.message}`);
+      return null;
     }
   }
 
@@ -219,18 +284,17 @@ class TemplateProcessor {
   }
 
   /**
-   * Initialize Claude client
+   * Initialize LLM provider
    */
-  initializeClaudeClient() {
-    if (!process.env.ANTHROPIC_API_KEY) {
-      console.log('⚠️  ANTHROPIC_API_KEY not found - AI suggestions will be skipped');
+  async initializeLLMProvider() {
+    try {
+      this.llmProvider = await LLMProvider.create(this._providerName, this._modelName);
+      return this.llmProvider;
+    } catch (error) {
+      console.log(`⚠️  Could not initialize ${this._providerName} provider - AI suggestions will be skipped`);
+      console.log(`   ${error.message}`);
       return null;
     }
-
-    this.claudeClient = new Anthropic({
-      apiKey: process.env.ANTHROPIC_API_KEY
-    });
-    return this.claudeClient;
   }
 
   /**
@@ -264,11 +328,12 @@ class TemplateProcessor {
   /**
    * Parse Claude's response into structured format
    */
-  parseClaudeResponse(response, isPlural) {
+  parseLLMResponse(response, isPlural) {
     if (isPlural) {
       return response.split('\n')
         .map(line => line.trim())
-        .filter(line => line.length > 0 && !line.match(/^[0-9\-*.]+\s/));
+        .filter(line => line.length > 0)
+        .map(line => line.replace(/^[0-9\-*.]+\s+/, '')); // Remove list prefixes
     }
     return response.trim();
   }
@@ -277,20 +342,14 @@ class TemplateProcessor {
    * Generate AI suggestions for a variable
    */
   async generateSuggestions(variableName, isPlural, context) {
-    if (!this.claudeClient && !this.initializeClaudeClient()) {
+    if (!this.llmProvider && !(await this.initializeLLMProvider())) {
       return null;
     }
 
     try {
       const prompt = this.buildPrompt(variableName, isPlural, context);
-
-      const response = await this.claudeClient.messages.create({
-        model: this.model,
-        max_tokens: isPlural ? 512 : 256,
-        messages: [{ role: "user", content: prompt }]
-      });
-
-      return this.parseClaudeResponse(response.content[0].text, isPlural);
+      const text = await this.llmProvider.generate(prompt, isPlural ? 512 : 256);
+      return this.parseLLMResponse(text, isPlural);
     } catch (error) {
       console.warn(`⚠️  Could not generate suggestions: ${error.message}`);
       return null;
@@ -304,14 +363,45 @@ class TemplateProcessor {
   async promptUser(variable, context) {
     let value;
 
-    if (variable.isPlural) {
-      value = await this.promptPlural(variable.displayName, variable.guidance);
+    // In non-interactive mode, skip readline prompts and use guidelines/AI
+    if (this.nonInteractive) {
+      console.log(`\n📝 ${variable.displayName}`);
+      if (variable.guidance) {
+        console.log(`   ${variable.guidance}`);
+      }
+      console.log('   Generating AI response...');
+      value = null; // Force AI generation
     } else {
-      value = await this.promptSingular(variable.displayName, variable.guidance);
+      // Interactive mode - use readline prompts
+      if (variable.isPlural) {
+        value = await this.promptPlural(variable.displayName, variable.guidance);
+      } else {
+        value = await this.promptSingular(variable.displayName, variable.guidance);
+      }
     }
 
-    // If user skipped, try to generate AI suggestions
+    // If user skipped (or non-interactive mode), try to use guideline or generate AI suggestions
     if (value === null) {
+      // Check if there's a guideline for this variable
+      const guidelines = this.readGuidelines();
+      const guidelineKey = variable.name.toLowerCase().replace(/_/g, '');
+
+      if (guidelines[guidelineKey]) {
+        console.log('   📋 Using default guideline...');
+        value = variable.isPlural
+          ? [guidelines[guidelineKey]]  // Wrap in array for plural variables
+          : guidelines[guidelineKey];
+
+        console.log('   ✅ Guideline applied:');
+        if (Array.isArray(value)) {
+          value.forEach((item, idx) => console.log(`      ${idx + 1}. ${item}`));
+        } else {
+          console.log(`      ${value}`);
+        }
+        return { variable: variable.name, value, source: 'guideline', skipped: true };
+      }
+
+      // No guideline available, try AI suggestions
       console.log('   ✨ Generating AI suggestion...');
       value = await this.generateSuggestions(variable.name, variable.isPlural, context);
 
@@ -361,20 +451,34 @@ class TemplateProcessor {
    * Generate final document with LLM enhancement
    */
   async generateFinalDocument(templateWithValues) {
-    if (!this.claudeClient && !this.initializeClaudeClient()) {
-      // No API key - save template as-is
+    if (!this.llmProvider && !(await this.initializeLLMProvider())) {
+      // No provider available - save template as-is
+      console.log('\n⚠️  AI enhancement skipped (no LLM provider available)');
       return templateWithValues;
     }
 
     console.log('\n🤖 Enhancing document with AI...');
 
     try {
-      const response = await this.claudeClient.messages.create({
-        model: this.model,
-        max_tokens: 4096,
-        messages: [{
-          role: "user",
-          content: `You are creating a project definition document for an Agile Vibe Coding (AVC) project.
+      // Try to load agent instructions for enhancement stage
+      const agentInstructions = this.getAgentForStage('enhancement');
+
+      if (agentInstructions) {
+        console.log('   Using custom agent instructions for enhancement');
+        // Use agent instructions as system context
+        const userPrompt = `Here is the project information with all variables filled in:
+
+${templateWithValues}
+
+Please review and enhance this document according to your role.`;
+
+        const enhanced = await this.llmProvider.generate(userPrompt, 4096, agentInstructions);
+        console.log('   ✓ Document enhanced successfully');
+        return enhanced;
+      } else {
+        console.log('   Using default enhancement instructions');
+        // Fallback to legacy hardcoded prompt for backward compatibility
+        const legacyPrompt = `You are creating a project definition document for an Agile Vibe Coding (AVC) project.
 
 Here is the project information with all variables filled in:
 
@@ -386,13 +490,15 @@ Please review and enhance this document to ensure:
 3. Sections flow logically
 4. Any incomplete sections are identified
 
-Return the enhanced markdown document.`
-        }]
-      });
+Return the enhanced markdown document.`;
 
-      return response.content[0].text;
+        const enhanced = await this.llmProvider.generate(legacyPrompt, 4096);
+        console.log('   ✓ Document enhanced successfully');
+        return enhanced;
+      }
     } catch (error) {
-      console.warn(`⚠️  Could not enhance document: ${error.message}`);
+      console.warn(`\n⚠️  Could not enhance document: ${error.message}`);
+      console.log('   Using template without AI enhancement');
       return templateWithValues;
     }
   }
@@ -406,6 +512,67 @@ Return the enhanced markdown document.`
     }
   }
 
+  /**
+   * Sync project documentation to VitePress documentation folder
+   */
+  syncToVitePress(content) {
+    try {
+      const docsDir = path.join(process.cwd(), '.avc/documentation');
+      const indexPath = path.join(docsDir, 'index.md');
+
+      // Check if documentation folder exists
+      if (!fs.existsSync(docsDir)) {
+        console.log('   ℹ️  VitePress documentation folder not found, skipping sync');
+        return false;
+      }
+
+      // Write to .avc/documentation/index.md
+      fs.writeFileSync(indexPath, content, 'utf8');
+      console.log(`   ✓ Synced to .avc/documentation/index.md`);
+      return true;
+    } catch (error) {
+      console.warn(`   ⚠️  Could not sync to VitePress: ${error.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Build VitePress documentation site
+   */
+  async buildVitePress() {
+    try {
+      const docsDir = path.join(process.cwd(), '.avc/documentation');
+      const packagePath = path.join(process.cwd(), 'package.json');
+
+      // Check if VitePress is configured
+      if (!fs.existsSync(docsDir) || !fs.existsSync(packagePath)) {
+        return false;
+      }
+
+      const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+      if (!packageJson.scripts?.['docs:build']) {
+        return false;
+      }
+
+      console.log('\n📚 Building VitePress documentation...');
+
+      // Import execSync for running build command
+      const { execSync } = await import('child_process');
+
+      // Run VitePress build
+      execSync('npm run docs:build', {
+        cwd: process.cwd(),
+        stdio: 'inherit'
+      });
+
+      console.log('✓ VitePress build completed');
+      return true;
+    } catch (error) {
+      console.warn(`⚠️  VitePress build failed: ${error.message}`);
+      return false;
+    }
+  }
+
   /**
    * Write document to file
    */
@@ -420,6 +587,14 @@ Return the enhanced markdown document.`
 
     console.log(`\n✅ Project document generated!`);
     console.log(`   Location: ${this.outputPath}`);
+
+    // Sync to VitePress if configured
+    const synced = this.syncToVitePress(content);
+
+    // Optionally build VitePress (commented out by default to avoid slow builds during dev)
+    // if (synced) {
+    //   await this.buildVitePress();
+    // }
   }
 
   /**
@@ -441,38 +616,64 @@ Return the enhanced markdown document.`
     if (initialProgress && initialProgress.collectedValues) {
       collectedValues = { ...initialProgress.collectedValues };
       answeredCount = Object.keys(collectedValues).length;
-      console.log(`Resuming with ${answeredCount}/${variables.length} questions already answered.\n`);
-    } else {
-      console.log(`Found ${variables.length} sections to complete.\n`);
-    }
 
-    // 4. Collect values with context accumulation
-    for (const variable of variables) {
-      // Skip already answered questions when resuming
-      if (collectedValues[variable.name] !== undefined) {
-        console.log(`\n✓ ${variable.displayName}`);
-        console.log(`   Using previous answer: ${
-          Array.isArray(collectedValues[variable.name])
-            ? `${collectedValues[variable.name].length} items`
-            : `"${collectedValues[variable.name].substring(0, 60)}${collectedValues[variable.name].length > 60 ? '...' : ''}"`
-        }`);
-        continue;
+      // Check if ALL answers are pre-filled (from REPL questionnaire)
+      if (answeredCount === variables.length) {
+        console.log(`✅ Using ${answeredCount} pre-filled answers from questionnaire.\n`);
+
+        // Use pre-filled answers, but still allow AI enhancement for skipped (null) answers
+        for (const variable of variables) {
+          if (collectedValues[variable.name] === null) {
+            console.log(`\n📝 ${variable.displayName}`);
+            console.log('   Generating AI suggestion...');
+            const aiValue = await this.generateSuggestions(variable.name, variable.isPlural, collectedValues);
+            collectedValues[variable.name] = aiValue || '';
+          }
+        }
+      } else {
+        console.log(`Resuming with ${answeredCount}/${variables.length} questions already answered.\n`);
+
+        // Continue with normal interactive flow for remaining questions
+        for (const variable of variables) {
+          if (collectedValues[variable.name] === undefined) {
+            const result = await this.promptUser(variable, collectedValues);
+            collectedValues[result.variable] = result.value;
+            answeredCount++;
+
+            // Save progress after each question
+            if (this.progressPath) {
+              const progress = {
+                stage: 'questionnaire',
+                totalQuestions: variables.length,
+                answeredQuestions: answeredCount,
+                collectedValues: collectedValues,
+                lastUpdate: new Date().toISOString()
+              };
+              this.saveProgress(progress);
+            }
+          }
+        }
       }
+    } else {
+      console.log(`Found ${variables.length} sections to complete.\n`);
 
-      const result = await this.promptUser(variable, collectedValues);
-      collectedValues[result.variable] = result.value;
-      answeredCount++;
-
-      // Save progress after each question
-      if (this.progressPath) {
-        const progress = {
-          stage: 'questionnaire',
-          totalQuestions: variables.length,
-          answeredQuestions: answeredCount,
-          collectedValues: collectedValues,
-          lastUpdate: new Date().toISOString()
-        };
-        this.saveProgress(progress);
+      // 4. Collect values with context accumulation
+      for (const variable of variables) {
+        const result = await this.promptUser(variable, collectedValues);
+        collectedValues[result.variable] = result.value;
+        answeredCount++;
+
+        // Save progress after each question
+        if (this.progressPath) {
+          const progress = {
+            stage: 'questionnaire',
+            totalQuestions: variables.length,
+            answeredQuestions: answeredCount,
+            collectedValues: collectedValues,
+            lastUpdate: new Date().toISOString()
+          };
+          this.saveProgress(progress);
+        }
       }
     }
 

package/cli/templates/vitepress-config.mts.template

@@ -0,0 +1,33 @@
+import { defineConfig } from 'vitepress'
+
+export default defineConfig({
+  title: '{{PROJECT_NAME}}',
+  description: 'Project documentation powered by Agile Vibe Coding',
+  base: '/',
+
+  // Custom head tags for AVC documentation identification
+  head: [
+    ['meta', { name: 'avc-documentation', content: 'true' }],
+    ['meta', { name: 'generator', content: 'Agile Vibe Coding' }]
+  ],
+
+  themeConfig: {
+    nav: [
+      { text: 'Home', link: '/' },
+      { text: 'Epics', link: '/epics' }
+    ],
+
+    sidebar: [
+      {
+        text: 'Project',
+        items: [
+          { text: 'Overview', link: '/' }
+        ]
+      }
+    ],
+
+    socialLinks: [
+      { icon: 'github', link: 'https://github.com/yourusername/yourproject' }
+    ]
+  }
+})

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agile-vibe-coding/avc",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Agile Vibe Coding (AVC) - Framework for managing AI agent-based software development projects",
   "type": "module",
   "main": "cli/index.js",
@@ -16,7 +16,12 @@
     "access": "public"
   },
   "scripts": {
-    "test": "echo \"No tests specified yet\" && exit 0",
+    "test": "vitest run",
+    "test:unit": "vitest run tests/unit",
+    "test:integration": "vitest run tests/integration",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage",
+    "test:ui": "vitest --ui",
     "prepublishOnly": "echo \"Running pre-publish checks...\" && npm test"
   },
   "keywords": [
@@ -49,10 +54,19 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.20.0",
+    "@google/genai": "^1.37.0",
     "dotenv": "^16.4.0",
     "ink": "^5.0.1",
     "ink-select-input": "^6.0.0",
     "ink-spinner": "^5.0.0",
     "react": "^18.3.1"
+  },
+  "devDependencies": {
+    "@sinonjs/fake-timers": "^12.0.0",
+    "@vitest/coverage-v8": "^2.1.9",
+    "@vitest/ui": "^2.1.9",
+    "memfs": "^4.56.10",
+    "sinon": "^19.0.5",
+    "vitest": "^2.1.9"
   }
-}
+}