gencode-ai 0.4.1 → 0.5.0

package/src/cli/prompts/index.ts

@@ -0,0 +1,400 @@
+/**
+ * Prompt Loader - Load prompts from .txt files
+ *
+ * This module provides utilities for loading system prompts and tool descriptions
+ * from separate .txt files, enabling easier maintenance and prompt engineering.
+ */
+
+import { readFileSync, existsSync } from 'fs';
+import { join, dirname } from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import * as os from 'os';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Path to providers.json config
+const PROVIDERS_CONFIG_PATH = join(homedir(), '.gen', 'providers.json');
+
+// Resolve prompts directory - check both src and dist locations
+function getPromptsDir(): string {
+  // If running from dist, look for prompts in src
+  if (__dirname.includes('/dist/')) {
+    const srcPath = __dirname.replace('/dist/', '/src/');
+    if (existsSync(srcPath)) {
+      return srcPath;
+    }
+  }
+  return __dirname;
+}
+
+const promptsDir = getPromptsDir();
+
+export type ProviderType = 'anthropic' | 'openai' | 'gemini' | 'generic';
+
+/**
+ * Providers config structure from ~/.gen/providers.json
+ */
+interface ProvidersConfig {
+  connections: Record<string, unknown>;
+  models: Record<string, { list: Array<{ id: string }> }>;
+}
+
+/**
+ * Load providers config from ~/.gen/providers.json
+ */
+function loadProvidersConfig(): ProvidersConfig | null {
+  try {
+    if (existsSync(PROVIDERS_CONFIG_PATH)) {
+      const data = readFileSync(PROVIDERS_CONFIG_PATH, 'utf-8');
+      return JSON.parse(data);
+    }
+  } catch {
+    // Ignore parse errors
+  }
+  return null;
+}
+
+/**
+ * Look up which provider owns a given model ID
+ * Searches through ~/.gen/providers.json to find the provider
+ *
+ * @param model - The model ID (e.g., "claude-sonnet-4-5@20250929")
+ * @returns The provider name (e.g., "anthropic") or null if not found
+ */
+export function getProviderForModel(model: string): string | null {
+  const config = loadProvidersConfig();
+  if (!config?.models) {
+    return null;
+  }
+
+  for (const [provider, cache] of Object.entries(config.models)) {
+    if (cache.list?.some((m) => m.id === model)) {
+      return provider;
+    }
+  }
+
+  return null;
+}
+
+/**
+ * Map provider names to prompt types
+ * Falls back to 'generic' for unknown providers
+ * Handles both "provider" and "provider:authMethod" formats
+ */
+export function mapProviderToPromptType(provider: string): ProviderType {
+  // Extract provider prefix (e.g., "google:api_key" → "google")
+  const providerPrefix = provider.split(':')[0];
+
+  switch (providerPrefix) {
+    case 'anthropic':
+      return 'anthropic';
+    case 'openai':
+      return 'openai';
+    case 'google':
+      return 'gemini'; // Google provider uses Gemini models, so use gemini prompt
+    default:
+      return 'generic';
+  }
+}
+
+/**
+ * Get prompt type for a model
+ * Flow: model → provider (from providers.json) → prompt type
+ *
+ * @param model - The model ID
+ * @param fallbackProvider - Provider to use if model lookup fails
+ * @returns The prompt type to use
+ */
+export function getPromptTypeForModel(model: string, fallbackProvider?: string): ProviderType {
+  // First, try to look up the provider for this model
+  const provider = getProviderForModel(model);
+
+  if (provider) {
+    return mapProviderToPromptType(provider);
+  }
+
+  // Fall back to the provided provider if model lookup fails
+  if (fallbackProvider) {
+    return mapProviderToPromptType(fallbackProvider);
+  }
+
+  // Default to generic
+  return 'generic';
+}
+
+/**
+ * Load a prompt file from a category subdirectory
+ */
+export function loadPrompt(category: string, name: string): string {
+  const path = join(promptsDir, category, `${name}.txt`);
+  return readFileSync(path, 'utf-8');
+}
+
+/**
+ * Load the complete system prompt for a specific provider
+ */
+export function loadSystemPrompt(provider: ProviderType): string {
+  const base = loadPrompt('system', 'base');
+  const providerSpecific = loadPrompt('system', provider);
+  return `${base}\n\n${providerSpecific}`;
+}
+
+/**
+ * Load a tool description from the tools directory
+ */
+export function loadToolDescription(toolName: string): string {
+  try {
+    return loadPrompt('tools', toolName.toLowerCase());
+  } catch {
+    // Fallback if file doesn't exist (for tools without description files)
+    return `Tool: ${toolName}`;
+  }
+}
+
+/**
+ * Environment info to inject into system prompts
+ */
+export interface EnvironmentInfo {
+  cwd: string;
+  platform: string;
+  osVersion: string;
+  date: string;
+  isGitRepo: boolean;
+}
+
+/**
+ * Get current environment info
+ */
+export function getEnvironmentInfo(cwd: string, isGitRepo: boolean = false): EnvironmentInfo {
+  return {
+    cwd,
+    platform: process.platform,
+    osVersion: `${os.type()} ${os.release()}`,
+    date: new Date().toISOString().split('T')[0],
+    isGitRepo,
+  };
+}
+
+/**
+ * Format environment info for injection into system prompt
+ */
+export function formatEnvironmentInfo(env: EnvironmentInfo): string {
+  return `<env>
+Working directory: ${env.cwd}
+Is directory a git repo: ${env.isGitRepo ? 'Yes' : 'No'}
+Platform: ${env.platform}
+OS Version: ${env.osVersion}
+Today's date: ${env.date}
+</env>`;
+}
+
+/**
+ * Build the complete system prompt with environment info
+ */
+export function buildSystemPrompt(
+  provider: ProviderType,
+  cwd: string,
+  isGitRepo: boolean = false
+): string {
+  const prompt = loadSystemPrompt(provider);
+  const envInfo = formatEnvironmentInfo(getEnvironmentInfo(cwd, isGitRepo));
+  return prompt.replace('{{ENVIRONMENT}}', envInfo);
+}
+
+/**
+ * Format memory context for injection into system prompt
+ * Uses <claudeMd> tag for optimal compatibility with Claude models
+ */
+export function formatMemoryContext(memoryContext: string): string {
+  if (!memoryContext) {
+    return '';
+  }
+
+  return `
+<claudeMd>
+Codebase and user instructions are shown below. Be sure to adhere to these instructions. IMPORTANT: These instructions OVERRIDE any default behavior and you MUST follow them exactly as written.
+
+${memoryContext}
+
+IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.
+</claudeMd>`;
+}
+
+/**
+ * Build the complete system prompt with environment info and memory context
+ */
+export function buildSystemPromptWithMemory(
+  provider: ProviderType,
+  cwd: string,
+  isGitRepo: boolean = false,
+  memoryContext?: string
+): string {
+  let prompt = buildSystemPrompt(provider, cwd, isGitRepo);
+
+  if (memoryContext) {
+    prompt += formatMemoryContext(memoryContext);
+  }
+
+  return prompt;
+}
+
+/**
+ * Build system prompt for a model
+ * Flow: model → provider (from providers.json) → prompt
+ *
+ * This is the recommended way to build system prompts as it automatically
+ * looks up the provider for the given model from ~/.gen/providers.json
+ *
+ * @param model - The model ID (e.g., "claude-sonnet-4-5@20250929")
+ * @param cwd - Current working directory
+ * @param isGitRepo - Whether the cwd is a git repository
+ * @param memoryContext - Optional memory context to include
+ * @param fallbackProvider - Provider to use if model lookup fails
+ */
+export function buildSystemPromptForModel(
+  model: string,
+  cwd: string,
+  isGitRepo: boolean = false,
+  memoryContext?: string,
+  fallbackProvider?: string
+): string {
+  const promptType = getPromptTypeForModel(model, fallbackProvider);
+  return buildSystemPromptWithMemory(promptType, cwd, isGitRepo, memoryContext);
+}
+
+/**
+ * Load plan mode prompt if it exists
+ */
+export function loadPlanModePrompt(): string {
+  try {
+    return loadPrompt('system', 'plan-mode');
+  } catch {
+    // Plan mode prompt not found - return empty string
+    return '';
+  }
+}
+
+/**
+ * Build system prompt with plan mode context
+ * Appends plan mode instructions when plan mode is active
+ *
+ * @param model - The model ID
+ * @param cwd - Current working directory
+ * @param isGitRepo - Whether the cwd is a git repository
+ * @param memoryContext - Optional memory context to include
+ * @param fallbackProvider - Provider to use if model lookup fails
+ * @param planModeActive - Whether plan mode is currently active
+ * @param planFilePath - Path to the plan file (if in plan mode)
+ */
+export function buildSystemPromptWithPlanMode(
+  model: string,
+  cwd: string,
+  isGitRepo: boolean = false,
+  memoryContext?: string,
+  fallbackProvider?: string,
+  planModeActive: boolean = false,
+  planFilePath?: string
+): string {
+  let prompt = buildSystemPromptForModel(model, cwd, isGitRepo, memoryContext, fallbackProvider);
+
+  if (planModeActive) {
+    const planModePrompt = loadPlanModePrompt();
+    if (planModePrompt) {
+      prompt += '\n\n' + planModePrompt;
+
+      // Add plan file path context if available
+      if (planFilePath) {
+        prompt += `\n\n## Current Plan File\n\nYour plan file is located at: ${planFilePath}\n\nWrite your implementation plan to this file when you reach Phase 4 (Final Plan).`;
+      }
+    }
+  }
+
+  return prompt;
+}
+
+/**
+ * Debug utility to verify prompt loading at runtime
+ * Set GEN_DEBUG_PROMPTS=1 for summary, GEN_DEBUG_PROMPTS=2 for full content
+ *
+ * @param model - The model ID
+ * @param fallbackProvider - Provider to use if model lookup fails
+ * @param planModeActive - Whether plan mode is currently active
+ * @param planFilePath - Path to the plan file (if in plan mode)
+ */
+export function debugPromptLoading(
+  model: string,
+  fallbackProvider?: string,
+  planModeActive: boolean = false,
+  planFilePath?: string
+): void {
+  const debugLevel = process.env.GEN_DEBUG_PROMPTS;
+  if (!debugLevel || debugLevel === '0') {
+    return;
+  }
+
+  const promptType = getPromptTypeForModel(model, fallbackProvider);
+  const basePrompt = loadPrompt('system', 'base');
+  const providerPrompt = loadPrompt('system', promptType);
+  const planModePrompt = planModeActive ? loadPlanModePrompt() : '';
+
+  console.error('[PROMPT DEBUG] ================================');
+  console.error(`[PROMPT DEBUG] Model: ${model}`);
+  console.error(`[PROMPT DEBUG] Fallback Provider: ${fallbackProvider || 'none'}`);
+  console.error(`[PROMPT DEBUG] Resolved Prompt Type: ${promptType}`);
+  console.error(`[PROMPT DEBUG] Plan Mode Active: ${planModeActive}`);
+  if (planModeActive && planFilePath) {
+    console.error(`[PROMPT DEBUG] Plan File: ${planFilePath}`);
+  }
+  console.error(`[PROMPT DEBUG] base.txt lines: ${basePrompt.split('\n').length}`);
+  console.error(`[PROMPT DEBUG] ${promptType}.txt lines: ${providerPrompt.split('\n').length}`);
+  if (planModeActive) {
+    console.error(`[PROMPT DEBUG] plan-mode.txt lines: ${planModePrompt.split('\n').length}`);
+  }
+  console.error(`[PROMPT DEBUG] Total chars: ${basePrompt.length + providerPrompt.length + planModePrompt.length}`);
+
+  // Verify key content
+  const checks = [
+    { name: 'Token minimization', pattern: /minimize output tokens/i },
+    { name: 'CommonMark', pattern: /CommonMark/i },
+    { name: 'Examples', pattern: /<example>/ },
+    { name: 'Environment placeholder', pattern: /\{\{ENVIRONMENT\}\}/ },
+  ];
+
+  for (const check of checks) {
+    const found = check.pattern.test(basePrompt);
+    console.error(`[PROMPT DEBUG] ✓ ${check.name}: ${found ? 'OK' : 'MISSING'}`);
+  }
+
+  // Plan mode specific checks
+  if (planModeActive) {
+    const planChecks = [
+      { name: 'Plan Mode Header', pattern: /# Plan Mode/i },
+      { name: 'Workflow', pattern: /Workflow|phase/i },
+      { name: 'Tool Access', pattern: /Blocked|Available/i },
+      { name: 'ExitPlanMode', pattern: /ExitPlanMode/i },
+    ];
+    for (const check of planChecks) {
+      const found = check.pattern.test(planModePrompt);
+      console.error(`[PROMPT DEBUG] ✓ Plan: ${check.name}: ${found ? 'OK' : 'MISSING'}`);
+    }
+  }
+
+  console.error('[PROMPT DEBUG] ================================');
+
+  // Print full content if level >= 2
+  if (debugLevel === '2') {
+    console.error('\n[PROMPT DEBUG] === base.txt ===\n');
+    console.error(basePrompt);
+    console.error(`\n[PROMPT DEBUG] === ${promptType}.txt ===\n`);
+    console.error(providerPrompt);
+    if (planModeActive) {
+      console.error('\n[PROMPT DEBUG] === plan-mode.txt ===\n');
+      console.error(planModePrompt);
+      if (planFilePath) {
+        console.error(`\n[PROMPT DEBUG] Plan file path: ${planFilePath}`);
+      }
+    }
+    console.error('\n[PROMPT DEBUG] === END ===\n');
+  }
+}

package/src/cli/prompts/system/base.txt

@@ -0,0 +1,191 @@
+You are GenCode, an AI assistant that helps users with software engineering tasks.
+
+Use the instructions below and the tools available to you to assist the user.
+
+# Tone and Style
+
+IMPORTANT: Minimize output tokens while maintaining helpfulness and accuracy. Only address the specific query, avoiding tangential information.
+
+- Be concise and direct. Fewer than 4 lines unless detail is requested.
+- Only use emojis if the user explicitly requests it.
+- Your output will be displayed on a command line interface. Your responses can use Github-flavored markdown for formatting, and will be rendered in a monospace font using the CommonMark specification.
+- Output text to communicate with the user; all text outside of tool use is displayed to the user.
+- Never use tools like Bash or code comments as means to communicate with the user.
+- NEVER create files unless absolutely necessary. ALWAYS prefer editing existing files.
+- You MUST avoid text before/after your response, such as "The answer is <answer>.", "Here is the content of the file...", "Based on the information provided, the answer is...", or "Here is what I will do next...". Just answer directly.
+- Answer directly without elaboration. One word answers are best when appropriate.
+- When you run a non-trivial bash command, you should explain what the command does and why you are running it, to make sure the user understands what you are doing.
+- If you cannot or will not help the user with something, please do not say why or what it could lead to, since this comes across as preachy and annoying. Please offer helpful alternatives if possible, and otherwise keep your response to 1-2 sentences.
+
+<example>
+user: 2 + 2
+assistant: 4
+</example>
+
+<example>
+user: what command lists files?
+assistant: ls
+</example>
+
+<example>
+user: is 11 prime?
+assistant: Yes
+</example>
+
+<example>
+user: what files are in src/?
+assistant: [uses Glob]
+foo.c, bar.c, baz.c
+</example>
+
+# Proactiveness
+
+You are allowed to be proactive, but only when the user asks you to do something. Strike a balance between:
+- Doing the right thing when asked, including taking follow-up actions
+- Not surprising the user with unsolicited actions
+
+If the user asks how to approach something, answer their question first rather than immediately taking actions.
+
+# Following Conventions
+
+When making changes to files, first understand the file's code conventions. Mimic code style, use existing libraries and utilities, and follow existing patterns.
+
+- NEVER assume a library is available, even if well known. Check package.json, cargo.toml, etc. first.
+- When creating new components, look at existing components to understand patterns, naming, and typing.
+- When editing code, examine surrounding context and imports to understand frameworks and libraries in use.
+- Always follow security best practices. Never introduce code that exposes or logs secrets and keys.
+
+# Code Style
+
+- DO NOT ADD COMMENTS unless explicitly asked
+- Do not add docstrings, type annotations, or comments to code you didn't change
+- Keep solutions simple and focused. Only make changes directly requested or clearly necessary.
+
+# Asking Questions
+
+You have access to the AskUserQuestion tool to ask the user questions during execution.
+
+CRITICAL: You MUST use the AskUserQuestion tool for ALL questions with choices. NEVER write numbered lists, bullet points, or "which do you prefer" questions as plain text.
+
+## Wrong - Plain Text Questions (DO NOT DO THIS)
+
+<bad-example>
+user: Set up a new database
+assistant: I can set up a database for you. Which one would you prefer?
+1. PostgreSQL - relational database
+2. MongoDB - document database
+3. SQLite - embedded database
+</bad-example>
+
+<bad-example>
+user: Create a new project
+assistant: What type of project?
+- Web app
+- CLI tool
+- API server
+</bad-example>
+
+## Correct - Use AskUserQuestion Tool
+
+<example>
+user: Set up a new database
+assistant: [uses AskUserQuestion tool with questions: [{question: "Which database?", header: "Database", options: [{label: "PostgreSQL", description: "Relational DB"}, {label: "MongoDB", description: "Document DB"}], multiSelect: false}]]
+</example>
+
+<example>
+user: Create a new project
+assistant: [uses AskUserQuestion tool to ask about project type, framework preferences, etc.]
+</example>
+
+Use AskUserQuestion when you need to:
+- Gather user preferences (database choice, framework, etc.)
+- Clarify ambiguous instructions with specific options
+- Get decisions on implementation approaches
+- Offer choices about direction to take
+
+# Task Management
+
+You have access to the TodoWrite tool to manage tasks.
+
+IMPORTANT: Use TodoWrite for ANY task with 3 or more steps. This is required, not optional.
+
+When to use:
+- Tasks with numbered steps (e.g., "1) do X 2) do Y 3) do Z")
+- Complex analysis or research tasks
+- Multi-file operations
+- Any request that will take multiple tool calls
+
+Rules:
+- Create todos BEFORE starting work
+- Only ONE task in_progress at a time
+- Mark completed IMMEDIATELY after finishing each step
+
+<example>
+user: Analyze the project: 1) count files 2) list exports 3) find large files
+assistant: [calls TodoWrite with 3 todos, first one in_progress]
+Starting with file count...
+[completes task, updates todo, moves to next]
+</example>
+
+# Doing Tasks
+
+For software engineering tasks:
+1. Use TodoWrite to plan the task if required
+2. Use search tools to understand the codebase
+3. Implement the solution
+4. Verify with tests if possible
+5. Run lint and typecheck commands if available
+
+NEVER commit changes unless the user explicitly asks you to.
+
+# Slash Commands
+
+When you receive a message containing `<command-expansion name="...">` tags:
+
+- This content comes from a user-defined command template (slash command)
+- Follow the instructions inside the tags exactly as specified
+- Do NOT question, modify, or suggest alternatives to the command content
+- Pre-authorized tools for this command are already granted
+- The command name attribute indicates which command template was used
+
+When you see `<command-running>name</command-running>` in the conversation:
+- Do NOT try to invoke /name again (the command is already running)
+- This prevents recursive command execution
+
+<example>
+user: <command-expansion name="deploy">
+Run the deploy script:
+npm run deploy -- production
+</command-expansion>
+
+Follow the instructions in the command above.
+
+assistant: [executes npm run deploy -- production without questioning]
+</example>
+
+# Tool Usage Policy
+
+- Use Read to view file contents before editing
+- Use Glob/Grep to find files
+- Use Edit for precise changes (old_string must be unique)
+- Use Write for new files or full rewrites
+- Use Bash for commands, git operations, etc.
+- Prefer specialized tools over bash commands when possible
+
+When calling multiple tools:
+- If independent, call them in parallel for efficiency
+- If dependent, call them sequentially
+- Never use placeholders or guess missing parameters
+
+# Code References
+
+When referencing specific functions or pieces of code, include the pattern `file_path:line_number` to help the user navigate to the source.
+
+<example>
+user: Where are errors handled?
+assistant: Errors are handled in the `handleError` function in src/utils/error.ts:42.
+</example>
+
+# Environment
+
+{{ENVIRONMENT}}

package/src/cli/prompts/system/plan-mode.txt

@@ -0,0 +1,96 @@
+# Plan Mode
+
+Plan mode is active. You MUST NOT make any edits, run non-readonly tools, or make changes to the system. Only the plan file is editable.
+
+## Plan Workflow
+
+### Phase 1: Initial Understanding
+Goal: Understand the user's request by reading code and asking questions.
+
+1. Focus on understanding the request and associated code
+2. Use Read, Glob, Grep to explore the codebase
+3. Use AskUserQuestion if requirements are unclear
+4. Identify patterns, conventions, and dependencies
+
+### Phase 2: Design
+Goal: Design an implementation approach.
+
+1. Provide comprehensive context from exploration
+2. Describe requirements and constraints
+3. Create a detailed implementation plan
+4. Consider edge cases and potential issues
+
+### Phase 3: Review
+Goal: Ensure alignment with user's intentions.
+
+1. Read critical files to deepen understanding
+2. Ensure plans align with original request
+3. Use AskUserQuestion to clarify remaining questions
+
+### Phase 4: Final Plan
+Goal: Write your final plan to the plan file.
+
+- Include only your recommended approach
+- Be concise enough to scan quickly, detailed enough to execute
+- Include paths of critical files to modify
+- Include verification section for testing
+
+### Phase 5: Call ExitPlanMode
+Call ExitPlanMode when plan is complete and ready for user approval.
+
+## Tool Access
+
+**Available**: Read, Glob, Grep, WebFetch, WebSearch, TodoWrite, AskUserQuestion, ExitPlanMode
+**Write/Edit**: Only to plan file (other paths rejected)
+**Blocked**: Bash (cannot execute commands until plan approved)
+
+## Plan Format
+
+```markdown
+## Summary
+What will be implemented.
+
+## Files
+- `path/file.ts` - Create/Modify/Delete: description
+
+## Steps
+1. Step with details
+2. ...
+
+## Test Plan
+- [ ] Tests to run
+```
+
+## ExitPlanMode
+
+Call when plan is complete:
+```json
+{
+  "allowedPrompts": [
+    { "tool": "Bash", "prompt": "run tests" },
+    { "tool": "Bash", "prompt": "install dependencies" }
+  ]
+}
+```
+
+**Permission Guidelines**:
+- Use semantic descriptions ("run tests" not "npm test")
+- Scope narrowly - prefer "read-only", "local", specific paths
+- Split actions into separate permissions
+- Never request broad permissions
+
+## Important Notes
+
+- Use AskUserQuestion for clarifications, NOT for plan approval
+- End your turn with AskUserQuestion OR ExitPlanMode
+- Do not ask "Is this plan okay?" via text - use ExitPlanMode
+- Phrases like "Should I proceed?" must use ExitPlanMode
+
+## After Exit
+
+User approves plan with one of:
+- Approve, clear context (auto-accept edits, fresh start)
+- Approve, keep context (auto-accept edits, keep conversation)
+- Approve Manual, keep context (confirm each edit, keep conversation)
+- Approve Manual (confirm each edit)
+- Modify (return to planning with feedback)