gencode-ai 0.1.1 → 0.1.3

package/docs/proposals/README.md

@@ -16,19 +16,20 @@ This directory contains enhancement proposals for the gencode project. Each prop
 
 | ID | Title | Status |
 |----|-------|--------|
-| [0001](./0001-web-fetch-tool.md) | WebFetch Tool | Draft |
-| [0002](./0002-web-search-tool.md) | WebSearch Tool | Draft |
+| [0001](./0001-web-fetch-tool.md) | WebFetch Tool | Implemented |
+| [0002](./0002-web-search-tool.md) | WebSearch Tool | Implemented |
 | [0003](./0003-task-subagents.md) | Task Tool & Subagents | Draft |
 | [0004](./0004-plan-mode.md) | Plan Mode | Draft |
-| [0005](./0005-todo-system.md) | Todo System | Draft |
-| [0006](./0006-memory-system.md) | Memory System (MYCODE.md) | Draft |
+| [0005](./0005-todo-system.md) | Todo System | Implemented |
+| [0006](./0006-memory-system.md) | Memory System (MYCODE.md) | Implemented |
 | [0007](./0007-context-management.md) | Context Management | Draft |
 | [0008](./0008-checkpointing.md) | Checkpointing | Draft |
 | [0009](./0009-hooks-system.md) | Hooks System | Draft |
 | [0010](./0010-mcp-integration.md) | MCP Integration | Draft |
 | [0011](./0011-custom-commands.md) | Custom Commands | Draft |
-| [0012](./0012-ask-user-question.md) | AskUserQuestion Tool | Draft |
-| [0041](./0041-configuration-system.md) | Configuration System | Draft |
+| [0012](./0012-ask-user-question.md) | AskUserQuestion Tool | Implemented |
+| [0041](./0041-configuration-system.md) | Configuration System | Implemented |
+| [0042](./0042-prompt-optimization.md) | Prompt System Optimization | Implemented |
 
 ### P2 Priority - Enhanced Features
 

package/examples/test-ask-user.ts

@@ -0,0 +1,167 @@
+/**
+ * Test script for AskUserQuestion tool
+ *
+ * Run with: npx tsx examples/test-ask-user.ts [mode]
+ *
+ * Modes:
+ *   single   - Single question, single select (default)
+ *   multi    - Single question, multi-select
+ *   multiple - Multiple questions with review screen
+ */
+
+import { render } from 'ink';
+import React from 'react';
+import { QuestionPrompt } from '../src/cli/components/QuestionPrompt.js';
+import type { Question, QuestionAnswer } from '../src/tools/types.js';
+
+// Test questions - matching Claude Code style
+const testQuestions: Question[] = [
+  {
+    question: 'What type of database would you like to create?',
+    header: 'DB Type',
+    options: [
+      {
+        label: 'PostgreSQL',
+        description: 'Powerful open-source relational database with advanced features like JSON support and full-text search',
+      },
+      {
+        label: 'MySQL',
+        description: 'Popular relational database, great for web applications and general-purpose use',
+      },
+      {
+        label: 'SQLite',
+        description: 'Lightweight file-based database, perfect for local development or embedded applications',
+      },
+      {
+        label: 'MongoDB',
+        description: 'NoSQL document database for flexible schema and JSON-like documents',
+      },
+    ],
+    multiSelect: false,
+  },
+];
+
+const testMultiSelectQuestions: Question[] = [
+  {
+    question: 'Which features should we enable for your project?',
+    header: 'Features',
+    options: [
+      {
+        label: 'TypeScript',
+        description: 'Type safety and better IDE support with static type checking',
+      },
+      {
+        label: 'ESLint + Prettier',
+        description: 'Code linting and automatic formatting for consistent code style',
+      },
+      {
+        label: 'Testing (Vitest)',
+        description: 'Fast unit testing framework with native ESM support',
+      },
+      {
+        label: 'Tailwind CSS',
+        description: 'Utility-first CSS framework for rapid UI development',
+      },
+    ],
+    multiSelect: true,
+  },
+];
+
+const testMultipleQuestions: Question[] = [
+  {
+    question: 'What type of database would you like to create?',
+    header: 'DB Type',
+    options: [
+      {
+        label: 'PostgreSQL',
+        description: 'Powerful open-source relational database with advanced features like JSON support and full-text search',
+      },
+      {
+        label: 'MySQL',
+        description: 'Popular relational database, great for web applications and general-purpose use',
+      },
+      {
+        label: 'SQLite',
+        description: 'Lightweight file-based database, perfect for local development or embedded applications',
+      },
+      {
+        label: 'MongoDB',
+        description: 'NoSQL document database for flexible schema and JSON-like documents',
+      },
+    ],
+    multiSelect: false,
+  },
+  {
+    question: 'What is the primary purpose of this database?',
+    header: 'Purpose',
+    options: [
+      {
+        label: 'GenCode project',
+        description: 'Add database functionality to the GenCode AI assistant project',
+      },
+      {
+        label: 'New project',
+        description: 'Create a database for a separate new project',
+      },
+      {
+        label: 'Learning/Testing',
+        description: 'Set up a database for experimentation and learning',
+      },
+    ],
+    multiSelect: false,
+  },
+];
+
+// Choose which test to run
+const testMode = process.argv[2] || 'single';
+
+let questions: Question[];
+switch (testMode) {
+  case 'multi':
+    questions = testMultiSelectQuestions;
+    console.log('\n=== Testing Multi-Select Mode ===\n');
+    break;
+  case 'multiple':
+    questions = testMultipleQuestions;
+    console.log('\n=== Testing Multiple Questions with Review ===\n');
+    break;
+  default:
+    questions = testQuestions;
+    console.log('\n=== Testing Single-Select Mode ===\n');
+}
+
+function TestApp() {
+  const handleComplete = (answers: QuestionAnswer[]) => {
+    console.log('\n\n=== Answers Received ===');
+    answers.forEach((answer, i) => {
+      console.log(`\n${i + 1}. ${answer.header}`);
+      console.log(`   Question: ${answer.question}`);
+      console.log(`   Selected: ${answer.selectedOptions.join(', ') || '(none)'}`);
+      if (answer.customInput) {
+        console.log(`   Custom: ${answer.customInput}`);
+      }
+    });
+    console.log('\n');
+    process.exit(0);
+  };
+
+  const handleCancel = () => {
+    console.log('\n\nCancelled by user\n');
+    process.exit(0);
+  };
+
+  return React.createElement(QuestionPrompt, {
+    questions,
+    onComplete: handleComplete,
+    onCancel: handleCancel,
+  });
+}
+
+// Render the test app
+const { unmount } = render(React.createElement(TestApp));
+
+// Handle Ctrl+C
+process.on('SIGINT', () => {
+  unmount();
+  process.exit(0);
+});

package/jest.config.js

@@ -0,0 +1,26 @@
+/** @type {import('ts-jest').JestConfigWithTsJest} */
+export default {
+  preset: 'ts-jest/presets/default-esm',
+  testEnvironment: 'node',
+  extensionsToTreatAsEsm: ['.ts'],
+  moduleNameMapper: {
+    '^(\\.{1,2}/.*)\\.js$': '$1',
+  },
+  transform: {
+    '^.+\\.tsx?$': [
+      'ts-jest',
+      {
+        useESM: true,
+        isolatedModules: true,
+      },
+    ],
+  },
+  testMatch: ['**/*.test.ts'],
+  collectCoverageFrom: [
+    'src/**/*.ts',
+    '!src/**/*.d.ts',
+    '!src/**/*.test.ts',
+  ],
+  coverageDirectory: 'coverage',
+  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx', 'json', 'node'],
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "gencode-ai",
-  "version": "0.1.1",
-  "description": "GenCode - An open-source, provider-agnostic AI coding assistant",
+  "version": "0.1.3",
+  "description": "An open-source AI assistant for your terminal",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -35,10 +35,12 @@
     "fast-glob": "^3.3.3",
     "glob": "^13.0.0",
     "google-auth-library": "^10.5.0",
+    "gray-matter": "^4.0.3",
     "ink": "^6.6.0",
     "ink-spinner": "^5.0.0",
     "ink-text-input": "^6.0.0",
     "marked": "^17.0.1",
+    "minimatch": "^10.1.1",
     "openai": "^6.16.0",
     "ora": "^9.0.0",
     "react": "^19.2.3",
@@ -47,8 +49,12 @@
     "zod": "^4.3.5"
   },
   "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@types/minimatch": "^5.1.2",
     "@types/node": "^25.0.8",
     "@types/react": "^19.2.8",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.6",
     "tsx": "^4.21.0",
     "typescript": "^5.9.3"
   }

package/src/agent/agent.ts

@@ -5,29 +5,33 @@
 import type { LLMProvider, Message, ToolResultContent } from '../providers/types.js';
 import { createProvider, inferProvider } from '../providers/index.js';
 import { ToolRegistry, createDefaultRegistry } from '../tools/index.js';
-import { PermissionManager } from '../permissions/index.js';
+import {
+  PermissionManager,
+  type ApprovalAction,
+  type ApprovalSuggestion,
+  type PromptPermission,
+  type PermissionSettings,
+} from '../permissions/index.js';
 import { SessionManager } from '../session/index.js';
+import { MemoryManager, type LoadedMemory } from '../memory/index.js';
 import type { AgentConfig, AgentEvent } from './types.js';
+import { buildSystemPromptForModel, debugPromptLoading } from '../prompts/index.js';
+import type { Question, QuestionAnswer } from '../tools/types.js';
 
-const DEFAULT_SYSTEM_PROMPT = `You are a helpful AI assistant with access to tools for reading, writing, and executing code.
-
-When using tools:
-- 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.
-
-Be concise and focus on completing the user's task.`;
+// Type for askUser callback
+export type AskUserCallback = (questions: Question[]) => Promise<QuestionAnswer[]>;
 
 export class Agent {
   private provider: LLMProvider;
   private registry: ToolRegistry;
   private permissions: PermissionManager;
   private sessionManager: SessionManager;
+  private memoryManager: MemoryManager;
   private config: AgentConfig;
   private messages: Message[] = [];
   private sessionId: string | null = null;
+  private loadedMemory: LoadedMemory | null = null;
+  private askUserCallback: AskUserCallback | null = null;
 
   constructor(config: AgentConfig) {
     this.config = {
@@ -38,17 +42,101 @@ export class Agent {
 
     this.provider = createProvider({ provider: config.provider });
     this.registry = createDefaultRegistry();
-    this.permissions = new PermissionManager(config.permissions);
+    this.permissions = new PermissionManager({
+      config: config.permissions,
+      projectPath: config.cwd,
+    });
     this.sessionManager = new SessionManager();
+    this.memoryManager = new MemoryManager();
+  }
+
+  /**
+   * Initialize permission system (load persisted rules)
+   */
+  async initializePermissions(settings?: PermissionSettings): Promise<void> {
+    await this.permissions.initialize(settings);
   }
 
   /**
-   * Set permission confirmation callback
+   * Set simple permission confirmation callback (backward compatible)
    */
   setConfirmCallback(callback: (tool: string, input: unknown) => Promise<boolean>): void {
+    this.permissions.setSimpleConfirmCallback(callback);
+  }
+
+  /**
+   * Set enhanced permission confirmation callback with approval options
+   */
+  setEnhancedConfirmCallback(
+    callback: (
+      tool: string,
+      input: unknown,
+      suggestions: ApprovalSuggestion[]
+    ) => Promise<ApprovalAction>
+  ): void {
     this.permissions.setConfirmCallback(callback);
   }
 
+  /**
+   * Add prompt-based permissions (Claude Code ExitPlanMode style)
+   */
+  addAllowedPrompts(prompts: PromptPermission[]): void {
+    this.permissions.addAllowedPrompts(prompts);
+  }
+
+  /**
+   * Clear prompt-based permissions
+   */
+  clearAllowedPrompts(): void {
+    this.permissions.clearAllowedPrompts();
+  }
+
+  /**
+   * Set callback to save permission rules to settings
+   * This enables saving rules to settings.local.json instead of permissions.json
+   */
+  setSaveRuleCallback(callback: (tool: string, pattern?: string) => Promise<void>): void {
+    this.permissions.setSaveRuleCallback(callback);
+  }
+
+  /**
+   * Get permission manager for direct access
+   */
+  getPermissionManager(): PermissionManager {
+    return this.permissions;
+  }
+
+  /**
+   * Set callback for AskUserQuestion tool
+   * This allows the CLI to handle user questioning
+   */
+  setAskUserCallback(callback: AskUserCallback): void {
+    this.askUserCallback = callback;
+  }
+
+  /**
+   * Get memory manager for direct access
+   */
+  getMemoryManager(): MemoryManager {
+    return this.memoryManager;
+  }
+
+  /**
+   * Get loaded memory (null if not loaded yet)
+   */
+  getLoadedMemory(): LoadedMemory | null {
+    return this.loadedMemory;
+  }
+
+  /**
+   * Load memory for the current working directory
+   */
+  async loadMemory(): Promise<LoadedMemory> {
+    const cwd = this.config.cwd ?? process.cwd();
+    this.loadedMemory = await this.memoryManager.load({ cwd });
+    return this.loadedMemory;
+  }
+
   /**
    * Get current session ID
    */
@@ -186,6 +274,11 @@ export class Agent {
       await this.startSession();
     }
 
+    // Load memory if not already loaded
+    if (!this.loadedMemory) {
+      await this.loadMemory();
+    }
+
     // Add user message
     const userMessage: Message = { role: 'user', content: prompt };
     this.messages.push(userMessage);
@@ -203,11 +296,26 @@ export class Agent {
       // Call LLM
       let response;
       try {
+        // Debug prompt loading (enabled with GENCODE_DEBUG_PROMPTS=1)
+        debugPromptLoading(this.config.model, this.config.provider);
+
+        // Build system prompt based on model → provider → prompt flow
+        // Looks up provider from ~/.gencode/providers.json, falls back to config.provider
+        const systemPrompt =
+          this.config.systemPrompt ??
+          buildSystemPromptForModel(
+            this.config.model,
+            this.config.cwd ?? process.cwd(),
+            true, // Assume git repo for now
+            this.loadedMemory?.context,
+            this.config.provider // Fallback provider if model lookup fails
+          );
+
         response = await this.provider.complete({
           model: this.config.model,
           messages: this.messages,
           tools: toolDefs,
-          systemPrompt: this.config.systemPrompt ?? DEFAULT_SYSTEM_PROMPT,
+          systemPrompt,
           maxTokens: 4096,
         });
       } catch (error) {
@@ -241,12 +349,18 @@ export class Agent {
       const toolResults: ToolResultContent[] = [];
       const cwd = this.config.cwd ?? process.cwd();
 
+      // Build tool context with askUser callback
+      const toolContext = {
+        cwd,
+        askUser: this.askUserCallback ?? undefined,
+      };
+
       for (const call of toolCalls) {
         yield { type: 'tool_start', id: call.id, name: call.name, input: call.input };
 
-        const allowed = await this.permissions.checkPermission(call.name, call.input);
+        const allowed = await this.permissions.requestPermission(call.name, call.input);
         const result = allowed
-          ? await this.registry.execute(call.name, call.input, { cwd })
+          ? await this.registry.execute(call.name, call.input, toolContext)
           : { success: false, output: '', error: 'Permission denied by user' };
 
         yield { type: 'tool_result', id: call.id, name: call.name, result };

package/src/agent/index.ts

@@ -4,3 +4,4 @@
 
 export * from './types.js';
 export { Agent } from './agent.js';
+export type { AskUserCallback } from './agent.js';

package/src/agent/types.ts

@@ -61,10 +61,22 @@ export interface AgentEventDone {
   text: string;
 }
 
+export interface AgentEventAskUser {
+  type: 'ask_user';
+  id: string;
+  questions: Array<{
+    question: string;
+    header: string;
+    options: Array<{ label: string; description: string }>;
+    multiSelect: boolean;
+  }>;
+}
+
 export type AgentEvent =
   | AgentEventText
   | AgentEventToolStart
   | AgentEventToolResult
   | AgentEventThinking
   | AgentEventError
-  | AgentEventDone;
+  | AgentEventDone
+  | AgentEventAskUser;