gencode-ai 0.1.1 → 0.1.2

package/src/permissions/types.ts

@@ -1,29 +1,257 @@
 /**
  * Permission System Types
+ * Enhanced permission management with pattern matching, prompt-based approvals,
+ * persistence, and audit logging - Claude Code compatible design.
  */
 
+// ============================================================================
+// Core Types
+// ============================================================================
+
 export type PermissionMode = 'auto' | 'confirm' | 'deny';
+export type PermissionScope = 'session' | 'project' | 'global';
+export type ApprovalAction = 'allow_once' | 'allow_session' | 'allow_always' | 'deny';
+
+// ============================================================================
+// Permission Rules
+// ============================================================================
 
+/**
+ * Permission rule for matching tool operations
+ * Claude Code style: "Bash(git add:*)"
+ */
 export interface PermissionRule {
+  /** Tool name or regex pattern */
   tool: string | RegExp;
+  /** Permission mode for matched operations */
   mode: PermissionMode;
+  /** Optional input pattern for matching (glob-style, e.g., "git add:*") */
+  pattern?: string | RegExp;
+  /** Semantic description for prompt-based matching */
+  prompt?: string;
+  /** Rule scope - where this rule applies */
+  scope?: PermissionScope;
+  /** Expiration timestamp for time-limited rules */
+  expiresAt?: Date;
+  /** Human-readable description of the rule */
+  description?: string;
+}
+
+/**
+ * Prompt-based permission (Claude Code ExitPlanMode style)
+ * { tool: "Bash", prompt: "run tests" }
+ */
+export interface PromptPermission {
+  /** Tool this permission applies to */
+  tool: string;
+  /** Semantic description of allowed action */
+  prompt: string;
 }
 
+// ============================================================================
+// Permission Config
+// ============================================================================
+
+/**
+ * Complete permission configuration
+ */
 export interface PermissionConfig {
+  /** Default mode for unmatched tools */
   defaultMode: PermissionMode;
+  /** Built-in and user-defined rules */
   rules: PermissionRule[];
+  /** Prompt-based permissions (from plan approval) */
+  allowedPrompts: PromptPermission[];
+}
+
+/**
+ * Serializable permission settings (for settings.json)
+ * Claude Code format: { allow: ["Bash(git add:*)"], ask: ["Bash(npm run:*)"], deny: ["Bash(rm -rf:*)"] }
+ */
+export interface PermissionSettings {
+  /** Allow patterns - auto-approve matching operations */
+  allow?: string[];
+  /** Ask patterns - require confirmation for matching operations */
+  ask?: string[];
+  /** Deny patterns - block matching operations */
+  deny?: string[];
+}
+
+// ============================================================================
+// Permission Context
+// ============================================================================
+
+/**
+ * Context for permission check
+ */
+export interface PermissionContext {
+  /** Tool being executed */
+  tool: string;
+  /** Tool input/parameters */
+  input: unknown;
+  /** Current session ID */
+  sessionId?: string;
+  /** Project path */
+  projectPath?: string;
+}
+
+// ============================================================================
+// Permission Decision
+// ============================================================================
+
+/**
+ * Result of a permission check
+ */
+export interface PermissionDecision {
+  /** Whether operation is allowed */
+  allowed: boolean;
+  /** Reason for the decision */
+  reason: string;
+  /** Rule that matched (if any) */
+  matchedRule?: PermissionRule | PromptPermission;
+  /** Whether user confirmation is required */
+  requiresConfirmation: boolean;
+  /** Suggested approval options */
+  suggestions?: ApprovalSuggestion[];
+}
+
+/**
+ * Approval option presented to user
+ */
+export interface ApprovalSuggestion {
+  /** Action identifier */
+  action: ApprovalAction;
+  /** User-facing label */
+  label: string;
+  /** Description of what this option does */
+  description?: string;
+  /** Keyboard shortcut (e.g., "1", "y") */
+  shortcut?: string;
 }
 
+// ============================================================================
+// Audit Types
+// ============================================================================
+
+export type AuditDecision = 'allowed' | 'denied' | 'confirmed' | 'rejected';
+
+/**
+ * Audit log entry for permission decisions
+ */
+export interface PermissionAuditEntry {
+  /** When the decision was made */
+  timestamp: Date;
+  /** Tool that was checked */
+  tool: string;
+  /** Summarized input (not full payload for privacy) */
+  inputSummary: string;
+  /** Final decision */
+  decision: AuditDecision;
+  /** Reason for decision */
+  reason: string;
+  /** Rule that matched (if any) */
+  matchedRule?: string;
+  /** Session ID */
+  sessionId?: string;
+}
+
+// ============================================================================
+// Persistence Types
+// ============================================================================
+
+/**
+ * Persisted rule for permanent storage
+ */
+export interface PersistedRule {
+  /** Unique rule ID */
+  id: string;
+  /** Tool pattern string */
+  tool: string;
+  /** Input pattern string */
+  pattern?: string;
+  /** Permission mode */
+  mode: PermissionMode;
+  /** Rule scope */
+  scope: PermissionScope;
+  /** When rule was created */
+  createdAt: string;
+  /** Description */
+  description?: string;
+}
+
+/**
+ * Persisted permissions file structure
+ */
+export interface PersistedPermissions {
+  /** Version for migration */
+  version: number;
+  /** Global rules */
+  rules: PersistedRule[];
+}
+
+// ============================================================================
+// Callback Types
+// ============================================================================
+
+/**
+ * Confirmation callback with approval options
+ */
+export type ConfirmCallback = (
+  tool: string,
+  input: unknown,
+  suggestions: ApprovalSuggestion[]
+) => Promise<ApprovalAction>;
+
+/**
+ * Simple yes/no confirmation callback (for backward compatibility)
+ */
+export type SimpleConfirmCallback = (tool: string, input: unknown) => Promise<boolean>;
+
+// ============================================================================
+// Default Configuration
+// ============================================================================
+
+/**
+ * Default permission configuration (Claude Code style)
+ * - Read-only tools auto-approved
+ * - Write operations require confirmation
+ * - Users can configure additional rules in settings.json
+ */
 export const DEFAULT_PERMISSION_CONFIG: PermissionConfig = {
   defaultMode: 'confirm',
   rules: [
-    // Read-only tools are auto-approved
-    { tool: 'Read', mode: 'auto' },
-    { tool: 'Glob', mode: 'auto' },
-    { tool: 'Grep', mode: 'auto' },
-    // Write operations require confirmation
-    { tool: 'Write', mode: 'confirm' },
-    { tool: 'Edit', mode: 'confirm' },
-    { tool: 'Bash', mode: 'confirm' },
+    // Read-only tools - auto-approve (Claude Code behavior)
+    { tool: 'Read', mode: 'auto', description: 'File reading' },
+    { tool: 'Glob', mode: 'auto', description: 'Pattern matching' },
+    { tool: 'Grep', mode: 'auto', description: 'Content search' },
+    { tool: 'LSP', mode: 'auto', description: 'Language server' },
+    // Internal state management - auto-approve (no side effects)
+    { tool: 'TodoWrite', mode: 'auto', description: 'Task tracking' },
   ],
+  allowedPrompts: [],
 };
+
+/**
+ * Default approval suggestions (Claude Code style)
+ * The second option dynamically shows the path context
+ */
+export const DEFAULT_SUGGESTIONS: ApprovalSuggestion[] = [
+  {
+    action: 'allow_once',
+    label: 'Yes',
+    description: 'Allow this operation',
+    shortcut: '1',
+  },
+  {
+    action: 'allow_always',
+    label: "Yes, and don't ask again",
+    description: 'Add to project allowlist',
+    shortcut: '2',
+  },
+  {
+    action: 'deny',
+    label: 'No',
+    description: 'Block this operation',
+    shortcut: '3',
+  },
+];

package/src/prompts/index.test.ts

@@ -0,0 +1,279 @@
+/**
+ * Prompt System Tests
+ *
+ * Tests to ensure prompts are correctly loaded and contain key guidance.
+ */
+
+import { describe, it, expect } from '@jest/globals';
+import {
+  loadPrompt,
+  loadSystemPrompt,
+  buildSystemPrompt,
+  buildSystemPromptWithMemory,
+  buildSystemPromptForModel,
+  mapProviderToPromptType,
+  getPromptTypeForModel,
+  formatEnvironmentInfo,
+  getEnvironmentInfo,
+  type ProviderType,
+} from './index.js';
+
+describe('Prompt Loader', () => {
+  describe('loadPrompt', () => {
+    it('should load base.txt from system category', () => {
+      const content = loadPrompt('system', 'base');
+      expect(content).toContain('GenCode');
+      expect(content.length).toBeGreaterThan(100);
+    });
+
+    it('should load provider-specific prompts', () => {
+      const providers: ProviderType[] = ['anthropic', 'openai', 'gemini', 'generic'];
+      for (const provider of providers) {
+        const content = loadPrompt('system', provider);
+        expect(content.length).toBeGreaterThan(0);
+      }
+    });
+
+    it('should load tool descriptions', () => {
+      const tools = ['read', 'write', 'edit', 'bash', 'glob', 'grep'];
+      for (const tool of tools) {
+        const content = loadPrompt('tools', tool);
+        expect(content.length).toBeGreaterThan(0);
+      }
+    });
+  });
+
+  describe('loadSystemPrompt', () => {
+    it('should concatenate base + provider prompts', () => {
+      const prompt = loadSystemPrompt('anthropic');
+
+      // Should contain base content
+      expect(prompt).toContain('GenCode');
+      expect(prompt).toContain('# Tone and Style');
+
+      // Should contain anthropic-specific content
+      expect(prompt).toContain('Claude');
+    });
+
+    it('should work for all provider types', () => {
+      const providers: ProviderType[] = ['anthropic', 'openai', 'gemini', 'generic'];
+      for (const provider of providers) {
+        const prompt = loadSystemPrompt(provider);
+        expect(prompt).toContain('GenCode');
+        expect(prompt.length).toBeGreaterThan(500);
+      }
+    });
+  });
+
+  describe('buildSystemPrompt', () => {
+    it('should inject environment info', () => {
+      const prompt = buildSystemPrompt('generic', '/tmp/test', true);
+
+      expect(prompt).toContain('<env>');
+      expect(prompt).toContain('Working directory: /tmp/test');
+      expect(prompt).toContain('Is directory a git repo: Yes');
+      expect(prompt).toContain('Platform:');
+      expect(prompt).toContain("Today's date:");
+      expect(prompt).toContain('</env>');
+    });
+
+    it('should replace {{ENVIRONMENT}} placeholder', () => {
+      const prompt = buildSystemPrompt('generic', '/test');
+      expect(prompt).not.toContain('{{ENVIRONMENT}}');
+    });
+  });
+
+  describe('buildSystemPromptWithMemory', () => {
+    it('should append memory context when provided', () => {
+      const memoryContext = '# Project Rules\n- Use TypeScript';
+      const prompt = buildSystemPromptWithMemory('generic', '/test', false, memoryContext);
+
+      expect(prompt).toContain('<claudeMd>');
+      expect(prompt).toContain('# Project Rules');
+      expect(prompt).toContain('Use TypeScript');
+      expect(prompt).toContain('</claudeMd>');
+    });
+
+    it('should not add memory section when context is empty', () => {
+      const prompt = buildSystemPromptWithMemory('generic', '/test', false);
+      expect(prompt).not.toContain('<claudeMd>');
+    });
+  });
+
+  describe('mapProviderToPromptType', () => {
+    it('should map known providers correctly', () => {
+      expect(mapProviderToPromptType('anthropic')).toBe('anthropic');
+      expect(mapProviderToPromptType('openai')).toBe('openai');
+      expect(mapProviderToPromptType('gemini')).toBe('gemini');
+    });
+
+    it('should return generic for unknown providers', () => {
+      expect(mapProviderToPromptType('unknown')).toBe('generic');
+      expect(mapProviderToPromptType('ollama')).toBe('generic');
+    });
+  });
+
+  describe('getPromptTypeForModel', () => {
+    it('should use fallback provider when model lookup fails', () => {
+      // Unknown model with fallback
+      expect(getPromptTypeForModel('unknown-model', 'anthropic')).toBe('anthropic');
+      expect(getPromptTypeForModel('unknown-model', 'openai')).toBe('openai');
+    });
+
+    it('should return generic when no fallback provided', () => {
+      expect(getPromptTypeForModel('unknown-model')).toBe('generic');
+    });
+  });
+
+  describe('buildSystemPromptForModel', () => {
+    it('should build prompt using fallback provider', () => {
+      const prompt = buildSystemPromptForModel(
+        'unknown-model',
+        '/test',
+        false,
+        undefined,
+        'anthropic'
+      );
+
+      expect(prompt).toContain('GenCode');
+      expect(prompt).toContain('Claude');
+    });
+  });
+
+  describe('Environment Info', () => {
+    it('should generate correct environment info', () => {
+      const env = getEnvironmentInfo('/my/project', true);
+
+      expect(env.cwd).toBe('/my/project');
+      expect(env.isGitRepo).toBe(true);
+      expect(env.platform).toBe(process.platform);
+      expect(env.date).toMatch(/^\d{4}-\d{2}-\d{2}$/);
+    });
+
+    it('should format environment info correctly', () => {
+      const env = getEnvironmentInfo('/test', false);
+      const formatted = formatEnvironmentInfo(env);
+
+      expect(formatted).toContain('<env>');
+      expect(formatted).toContain('Working directory: /test');
+      expect(formatted).toContain('Is directory a git repo: No');
+      expect(formatted).toContain('</env>');
+    });
+  });
+});
+
+describe('Prompt Content Validation', () => {
+  describe('base.txt - Claude Code key guidance', () => {
+    let basePrompt: string;
+
+    beforeAll(() => {
+      basePrompt = loadPrompt('system', 'base');
+    });
+
+    it('should contain token minimization guidance', () => {
+      expect(basePrompt).toMatch(/minimize output tokens/i);
+    });
+
+    it('should contain CommonMark rendering info', () => {
+      expect(basePrompt).toMatch(/CommonMark/i);
+    });
+
+    it('should contain forbidden preamble/postamble phrases', () => {
+      expect(basePrompt).toContain('The answer is');
+      expect(basePrompt).toContain('Here is the content');
+    });
+
+    it('should contain conciseness guidance', () => {
+      expect(basePrompt).toMatch(/concise|fewer than 4 lines/i);
+    });
+
+    it('should contain non-preachy refusal guidance', () => {
+      expect(basePrompt).toMatch(/preachy|annoying/i);
+    });
+
+    it('should contain examples', () => {
+      expect(basePrompt).toContain('<example>');
+      expect(basePrompt).toContain('</example>');
+      // Verify at least one simple example
+      expect(basePrompt).toMatch(/2 \+ 2[\s\S]*?4/);
+    });
+
+    it('should contain task management section', () => {
+      expect(basePrompt).toContain('TodoWrite');
+    });
+
+    it('should contain tool usage policy', () => {
+      expect(basePrompt).toContain('Tool Usage');
+    });
+
+    it('should contain environment placeholder', () => {
+      expect(basePrompt).toContain('{{ENVIRONMENT}}');
+    });
+  });
+
+  describe('generic.txt - standalone comprehensive prompt', () => {
+    let genericPrompt: string;
+
+    beforeAll(() => {
+      genericPrompt = loadPrompt('system', 'generic');
+    });
+
+    it('should contain token minimization guidance', () => {
+      expect(genericPrompt).toMatch(/minimize output tokens/i);
+    });
+
+    it('should contain tool selection guidelines table', () => {
+      expect(genericPrompt).toContain('| Task | Tool |');
+    });
+
+    it('should contain software engineering workflow', () => {
+      expect(genericPrompt).toContain('Software Engineering Workflow');
+    });
+
+    it('should contain security guidance', () => {
+      expect(genericPrompt).toMatch(/security|secrets/i);
+    });
+
+    it('should contain examples', () => {
+      expect(genericPrompt).toContain('<example>');
+      const exampleCount = (genericPrompt.match(/<example>/g) || []).length;
+      expect(exampleCount).toBeGreaterThanOrEqual(3);
+    });
+  });
+
+  describe('Provider-specific prompts', () => {
+    it('anthropic.txt should reference Claude capabilities', () => {
+      const prompt = loadPrompt('system', 'anthropic');
+      expect(prompt).toMatch(/claude|thinking|anthropic/i);
+    });
+
+    it('openai.txt should reference GPT capabilities', () => {
+      const prompt = loadPrompt('system', 'openai');
+      expect(prompt).toMatch(/gpt|openai|structured/i);
+    });
+
+    it('gemini.txt should reference Gemini capabilities', () => {
+      const prompt = loadPrompt('system', 'gemini');
+      expect(prompt).toMatch(/gemini|google|multimodal/i);
+    });
+  });
+});
+
+describe('Tool Description Validation', () => {
+  const requiredTools = ['read', 'write', 'edit', 'bash', 'glob', 'grep', 'todowrite'];
+
+  it.each(requiredTools)('should have description for %s tool', (tool) => {
+    const description = loadPrompt('tools', tool);
+    expect(description.length).toBeGreaterThan(50);
+  });
+
+  it('bash.txt should contain git safety guidance', () => {
+    const bash = loadPrompt('tools', 'bash');
+    expect(bash).toMatch(/git|commit/i);
+  });
+
+  it('todowrite.txt should contain task state guidance', () => {
+    const todo = loadPrompt('tools', 'todowrite');
+    expect(todo).toMatch(/pending|in_progress|completed/i);
+  });
+});