gencode-ai 0.2.0 → 0.3.0

package/src/memory/types.ts

@@ -2,15 +2,15 @@
  * Memory System Types
  *
  * Hierarchical memory loading compatible with Claude Code:
- * At each level, both .gencode and .claude are loaded and merged (gencode has higher priority).
+ * At each level, both .gen and .claude are loaded and merged (gen has higher priority).
  *
  * Levels:
  * - Enterprise: System-wide managed memory (enforced)
- * - User: ~/.gencode/ + ~/.claude/ (both loaded, gencode content appears later)
- * - User Rules: ~/.gencode/rules/ + ~/.claude/rules/
- * - Extra: GENCODE_CONFIG_DIRS directories
- * - Project: ./AGENT.md, .gencode/, ./CLAUDE.md, .claude/ (recursive upward search)
- * - Project Rules: .gencode/rules/ + .claude/rules/
+ * - User: ~/.gen/ + ~/.claude/ (both loaded, gen content appears later)
+ * - User Rules: ~/.gen/rules/ + ~/.claude/rules/
+ * - Extra: GEN_CONFIG_DIRS directories
+ * - Project: ./GEN.md, .gen/, ./CLAUDE.md, .claude/ (recursive upward search)
+ * - Project Rules: .gen/rules/ + .claude/rules/
  * - Local: *.local.md files (gitignored)
  */
 
@@ -23,7 +23,16 @@ export type MemoryLevel =
   | 'project-rules'
   | 'local';
 
-export type MemoryNamespace = 'gencode' | 'claude' | 'extra';
+export type MemoryNamespace = 'gen' | 'claude' | 'extra';
+
+/**
+ * Memory merge strategy - how to combine CLAUDE.md and GEN.md at each level
+ * - fallback: Load GEN.md if exists, else CLAUDE.md (reduces context, default)
+ * - both: Load both CLAUDE.md and GEN.md (current behavior, max context)
+ * - gen-only: Only load .gen/GEN.md files
+ * - claude-only: Only load .claude/CLAUDE.md files
+ */
+export type MemoryMergeStrategy = 'fallback' | 'both' | 'gen-only' | 'claude-only';
 
 export interface MemoryFile {
   path: string;
@@ -46,9 +55,9 @@ export interface MemoryRule {
 
 export interface MemoryConfig {
   // GenCode file names (higher priority)
-  gencodeFilename: string;
-  gencodeLocalFilename: string;
-  gencodeDir: string;
+  genFilename: string;
+  genLocalFilename: string;
+  genDir: string;
 
   // Claude file names (lower priority, loaded first)
   claudeFilename: string;
@@ -64,9 +73,9 @@ export interface MemoryConfig {
 
 export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {
   // GenCode
-  gencodeFilename: 'AGENT.md',
-  gencodeLocalFilename: 'AGENT.local.md',
-  gencodeDir: '.gencode',
+  genFilename: 'GEN.md',
+  genLocalFilename: 'GEN.local.md',
+  genDir: '.gen',
 
   // Claude
   claudeFilename: 'CLAUDE.md',
@@ -82,13 +91,13 @@ export const DEFAULT_MEMORY_CONFIG: MemoryConfig = {
 
 // Legacy compatibility
 export const LEGACY_MEMORY_CONFIG = {
-  primaryFilename: 'AGENT.md',
+  primaryFilename: 'GEN.md',
   fallbackFilename: 'CLAUDE.md',
-  localFilename: 'AGENT.local.md',
+  localFilename: 'GEN.local.md',
   localFallbackFilename: 'CLAUDE.local.md',
-  primaryUserDir: '.gencode',
+  primaryUserDir: '.gen',
   fallbackUserDir: '.claude',
-  primaryLocalDir: '.gencode',
+  primaryLocalDir: '.gen',
   fallbackLocalDir: '.claude',
   rulesDir: 'rules',
   maxFileSize: 100 * 1024,
@@ -103,6 +112,7 @@ export interface LoadedMemory {
   context: string;
   errors: string[];
   sources: MemorySource[]; // For debugging
+  skippedFiles: string[]; // Files skipped due to merge strategy
 }
 
 export interface MemorySource {
@@ -116,4 +126,5 @@ export interface MemorySource {
 export interface MemoryLoadOptions {
   cwd: string;
   currentFile?: string; // For activating path-scoped rules
+  strategy?: MemoryMergeStrategy; // How to merge CLAUDE.md and AGENT.md (default: 'fallback')
 }

package/src/permissions/persistence.ts

@@ -2,8 +2,8 @@
  * Permission Persistence - Store and load permission rules
  *
  * Handles persistent storage of permission rules at:
- * - Global: ~/.gencode/permissions.json
- * - Project: .gencode/permissions.json
+ * - Global: ~/.gen/permissions.json
+ * - Project: .gen/permissions.json
  */
 
 import * as fs from 'fs/promises';
@@ -21,7 +21,7 @@ import { parsePatternString } from './prompt-matcher.js';
 
 const PERMISSIONS_VERSION = 1;
 const PERMISSIONS_FILE = 'permissions.json';
-const GLOBAL_DIR = path.join(os.homedir(), '.gencode');
+const GLOBAL_DIR = path.join(os.homedir(), '.gen');
 
 /**
  * Permission Persistence Manager
@@ -32,7 +32,7 @@ export class PermissionPersistence {
 
   constructor(projectPath?: string) {
     this.globalDir = GLOBAL_DIR;
-    this.projectDir = projectPath ? path.join(projectPath, '.gencode') : null;
+    this.projectDir = projectPath ? path.join(projectPath, '.gen') : null;
   }
 
   /**

package/src/planning/plan-file.ts

@@ -1,7 +1,7 @@
 /**
  * Plan File Utilities
  *
- * Manages plan files stored in .gencode/plans/ directory.
+ * Manages plan files stored in .gen/plans/ directory.
  * Generates unique filenames with timestamps and slugs.
  */
 
@@ -14,7 +14,7 @@ import type { PlanFile } from './types.js';
 // Constants
 // ============================================================================
 
-const PLANS_DIR = '.gencode/plans';
+const PLANS_DIR = '.gen/plans';
 const PLAN_FILE_EXTENSION = '.md';
 
 // Word lists for generating memorable names (like Claude Code)

package/src/prompts/index.ts

@@ -14,7 +14,7 @@ import * as os from 'os';
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 // Path to providers.json config
-const PROVIDERS_CONFIG_PATH = join(homedir(), '.gencode', 'providers.json');
+const PROVIDERS_CONFIG_PATH = join(homedir(), '.gen', 'providers.json');
 
 // Resolve prompts directory - check both src and dist locations
 function getPromptsDir(): string {
@@ -33,7 +33,7 @@ const promptsDir = getPromptsDir();
 export type ProviderType = 'anthropic' | 'openai' | 'gemini' | 'generic';
 
 /**
- * Providers config structure from ~/.gencode/providers.json
+ * Providers config structure from ~/.gen/providers.json
  */
 interface ProvidersConfig {
   connections: Record<string, unknown>;
@@ -41,7 +41,7 @@ interface ProvidersConfig {
 }
 
 /**
- * Load providers config from ~/.gencode/providers.json
+ * Load providers config from ~/.gen/providers.json
  */
 function loadProvidersConfig(): ProvidersConfig | null {
   try {
@@ -57,7 +57,7 @@ function loadProvidersConfig(): ProvidersConfig | null {
 
 /**
  * Look up which provider owns a given model ID
- * Searches through ~/.gencode/providers.json to find the provider
+ * 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
@@ -80,9 +80,13 @@ export function getProviderForModel(model: string): string | 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 {
-  switch (provider) {
+  // Extract provider prefix (e.g., "gemini:api_key" → "gemini")
+  const providerPrefix = provider.split(':')[0];
+
+  switch (providerPrefix) {
     case 'anthropic':
       return 'anthropic';
     case 'openai':
@@ -200,7 +204,7 @@ export function buildSystemPrompt(
 
 /**
  * Format memory context for injection into system prompt
- * Uses <claudeMd> tag for Claude Code compatibility
+ * Uses <claudeMd> tag for optimal compatibility with Claude models
  */
 export function formatMemoryContext(memoryContext: string): string {
   if (!memoryContext) {
@@ -240,7 +244,7 @@ export function buildSystemPromptWithMemory(
  * 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 ~/.gencode/providers.json
+ * 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
@@ -261,10 +265,10 @@ export function buildSystemPromptForModel(
 
 /**
  * Debug utility to verify prompt loading at runtime
- * Set GENCODE_DEBUG_PROMPTS=1 for summary, GENCODE_DEBUG_PROMPTS=2 for full content
+ * Set GEN_DEBUG_PROMPTS=1 for summary, GEN_DEBUG_PROMPTS=2 for full content
  */
 export function debugPromptLoading(model: string, fallbackProvider?: string): void {
-  const debugLevel = process.env.GENCODE_DEBUG_PROMPTS;
+  const debugLevel = process.env.GEN_DEBUG_PROMPTS;
   if (!debugLevel || debugLevel === '0') {
     return;
   }

package/src/providers/anthropic.ts

@@ -7,6 +7,7 @@ import Anthropic from '@anthropic-ai/sdk';
 import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -23,6 +24,14 @@ type AnthropicTool = Anthropic.Tool;
 type AnthropicContent = Anthropic.ContentBlockParam;
 
 export class AnthropicProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'anthropic',
+    authMethod: 'api_key',
+    envVars: ['ANTHROPIC_API_KEY'],
+    displayName: 'Direct API',
+    description: 'Direct API access',
+  };
+
   readonly name = 'anthropic';
   private client: Anthropic;
 

package/src/providers/gemini.ts

@@ -8,6 +8,7 @@ import type { Content, Part, Tool, GenerateContentResult } from '@google/generat
 import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -21,6 +22,14 @@ import type {
 } from './types.js';
 
 export class GeminiProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'gemini',
+    authMethod: 'api_key',
+    envVars: ['GOOGLE_API_KEY', 'GEMINI_API_KEY'],
+    displayName: 'Direct API',
+    description: 'Direct API access',
+  };
+
   readonly name = 'gemini';
   private client: GoogleGenerativeAI;
   private apiKey: string;

package/src/providers/index.ts

@@ -6,56 +6,80 @@ export * from './types.js';
 export { OpenAIProvider } from './openai.js';
 export { AnthropicProvider } from './anthropic.js';
 export { GeminiProvider } from './gemini.js';
-export { VertexAIProvider } from './vertex-ai.js';
+export { AnthropicVertexProvider } from './vertex-ai.js';
 
-import type { LLMProvider, OpenAIConfig, AnthropicConfig, GeminiConfig, VertexAIConfig } from './types.js';
+import type {
+  LLMProvider,
+  Provider,
+  AuthMethod,
+  OpenAIConfig,
+  AnthropicConfig,
+  GeminiConfig,
+  VertexAIConfig,
+} from './types.js';
 import { OpenAIProvider } from './openai.js';
 import { AnthropicProvider } from './anthropic.js';
 import { GeminiProvider } from './gemini.js';
-import { VertexAIProvider } from './vertex-ai.js';
+import { AnthropicVertexProvider } from './vertex-ai.js';
+
+// Legacy type alias for backward compatibility
+/** @deprecated Use Provider instead */
+export type ProviderName = Provider;
 
-export type ProviderName = 'openai' | 'anthropic' | 'gemini' | 'vertex-ai';
 export type ProviderConfigMap = {
   openai: OpenAIConfig;
   anthropic: AnthropicConfig;
   gemini: GeminiConfig;
-  'vertex-ai': VertexAIConfig;
 };
 
-export interface CreateProviderOptions<T extends ProviderName = ProviderName> {
-  provider: T;
-  config?: ProviderConfigMap[T];
+export interface CreateProviderOptions {
+  provider: Provider;
+  authMethod?: AuthMethod;
+  config?: OpenAIConfig | AnthropicConfig | GeminiConfig | VertexAIConfig;
 }
 
 /**
- * Create a provider instance by name
+ * Create a provider instance by provider and auth method
+ * If authMethod is not provided, defaults to 'api_key'
  */
 export function createProvider(options: CreateProviderOptions): LLMProvider {
-  switch (options.provider) {
-    case 'openai':
-      return new OpenAIProvider(options.config as OpenAIConfig);
-    case 'anthropic':
-      return new AnthropicProvider(options.config as AnthropicConfig);
-    case 'gemini':
-      return new GeminiProvider(options.config as GeminiConfig);
-    case 'vertex-ai':
-      return new VertexAIProvider(options.config as VertexAIConfig);
-    default:
-      throw new Error(`Unknown provider: ${options.provider}`);
+  const { provider, authMethod = 'api_key', config } = options;
+
+  // Map provider + authMethod to the correct implementation
+  if (provider === 'anthropic') {
+    if (authMethod === 'vertex') {
+      return new AnthropicVertexProvider(config as VertexAIConfig);
+    } else if (authMethod === 'api_key') {
+      return new AnthropicProvider(config as AnthropicConfig);
+    }
+    throw new Error(`Unsupported auth method for anthropic: ${authMethod}`);
+  }
+
+  if (provider === 'openai') {
+    if (authMethod === 'api_key') {
+      return new OpenAIProvider(config as OpenAIConfig);
+    }
+    throw new Error(`Unsupported auth method for openai: ${authMethod}`);
+  }
+
+  if (provider === 'gemini') {
+    if (authMethod === 'api_key') {
+      return new GeminiProvider(config as GeminiConfig);
+    }
+    throw new Error(`Unsupported auth method for gemini: ${authMethod}`);
   }
+
+  throw new Error(`Unknown provider: ${provider}`);
 }
 
 /**
  * Infer provider from model name
+ * Note: This only returns the provider, not the auth method
+ * For Vertex AI models (claude-*@version), this returns 'anthropic'
  */
-export function inferProvider(model: string): ProviderName {
+export function inferProvider(model: string): Provider {
   const modelLower = model.toLowerCase();
 
-  // Vertex AI models (Claude models with @ version suffix like claude-sonnet-4-5@20250929)
-  if (modelLower.includes('claude') && modelLower.includes('@')) {
-    return 'vertex-ai';
-  }
-
   // OpenAI models
   if (
     modelLower.includes('gpt') ||
@@ -68,7 +92,7 @@ export function inferProvider(model: string): ProviderName {
     return 'openai';
   }
 
-  // Anthropic models
+  // Anthropic models (including Vertex AI format with @)
   if (modelLower.includes('claude')) {
     return 'anthropic';
   }
@@ -82,10 +106,29 @@ export function inferProvider(model: string): ProviderName {
   return 'openai';
 }
 
+/**
+ * Infer auth method from model name
+ * Returns undefined if auth method cannot be inferred
+ */
+export function inferAuthMethod(model: string): AuthMethod | undefined {
+  const modelLower = model.toLowerCase();
+
+  // Vertex AI models (Claude models with @ version suffix like claude-sonnet-4-5@20250929)
+  if (modelLower.includes('claude') && modelLower.includes('@')) {
+    return 'vertex';
+  }
+
+  // For other models, we can't reliably infer auth method
+  return undefined;
+}
+
 /**
  * Common model aliases
  */
-export const ModelAliases: Record<string, { provider: ProviderName; model: string }> = {
+export const ModelAliases: Record<
+  string,
+  { provider: Provider; authMethod?: AuthMethod; model: string }
+> = {
   // OpenAI
   'gpt-4o': { provider: 'openai', model: 'gpt-4o' },
   'gpt-4o-mini': { provider: 'openai', model: 'gpt-4o-mini' },
@@ -94,7 +137,7 @@ export const ModelAliases: Record<string, { provider: ProviderName; model: strin
   'o1-mini': { provider: 'openai', model: 'o1-mini' },
   'o3-mini': { provider: 'openai', model: 'o3-mini' },
 
-  // Anthropic
+  // Anthropic (Direct API)
   'claude-opus': { provider: 'anthropic', model: 'claude-opus-4-5-20251101' },
   'claude-sonnet': { provider: 'anthropic', model: 'claude-sonnet-4-20250514' },
   'claude-haiku': { provider: 'anthropic', model: 'claude-haiku-4-20250514' },
@@ -105,8 +148,8 @@ export const ModelAliases: Record<string, { provider: ProviderName; model: strin
   'gemini-1.5-pro': { provider: 'gemini', model: 'gemini-1.5-pro' },
   'gemini-1.5-flash': { provider: 'gemini', model: 'gemini-1.5-flash' },
 
-  // Vertex AI (Claude on GCP)
-  'vertex-sonnet': { provider: 'vertex-ai', model: 'claude-sonnet-4-5@20250929' },
-  'vertex-haiku': { provider: 'vertex-ai', model: 'claude-haiku-4-5@20251001' },
-  'vertex-opus': { provider: 'vertex-ai', model: 'claude-opus-4-1@20250805' },
+  // Anthropic via Vertex AI
+  'vertex-sonnet': { provider: 'anthropic', authMethod: 'vertex', model: 'claude-sonnet-4-5@20250929' },
+  'vertex-haiku': { provider: 'anthropic', authMethod: 'vertex', model: 'claude-haiku-4-5@20251001' },
+  'vertex-opus': { provider: 'anthropic', authMethod: 'vertex', model: 'claude-opus-4-1@20250805' },
 };

package/src/providers/openai.ts

@@ -7,6 +7,7 @@ import OpenAI from 'openai';
 import { calculateCost } from '../pricing/calculator.js';
 import type {
   LLMProvider,
+  ProviderClassMeta,
   CompletionOptions,
   CompletionResponse,
   StreamChunk,
@@ -22,6 +23,14 @@ type OpenAIMessage = OpenAI.Chat.Completions.ChatCompletionMessageParam;
 type OpenAITool = OpenAI.Chat.Completions.ChatCompletionTool;
 
 export class OpenAIProvider implements LLMProvider {
+  static readonly meta: ProviderClassMeta = {
+    provider: 'openai',
+    authMethod: 'api_key',
+    envVars: ['OPENAI_API_KEY'],
+    displayName: 'Direct API',
+    description: 'Direct API access',
+  };
+
   readonly name = 'openai';
   private client: OpenAI;