genesis-ai-cli 7.4.5

package/dist/src/memory/indexer.js

@@ -0,0 +1,479 @@
+"use strict";
+/**
+ * Genesis 6.8 - Project Indexer
+ *
+ * Indexes project files for local full-text search.
+ * No LLM needed for code search - instant results.
+ *
+ * Uses JSON storage with in-memory trigram index for fast search.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ProjectIndexer = void 0;
+exports.getProjectIndexer = getProjectIndexer;
+exports.resetProjectIndexer = resetProjectIndexer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const crypto = __importStar(require("crypto"));
+// ============================================================================
+// Default Config
+// ============================================================================
+const DEFAULT_CONFIG = {
+    projectRoot: process.cwd(),
+    indexPath: path.join(process.cwd(), '.genesis', 'index.json'),
+    include: [
+        '**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx',
+        '**/*.py', '**/*.go', '**/*.rs', '**/*.java',
+        '**/*.md', '**/*.json', '**/*.yaml', '**/*.yml',
+        '**/*.html', '**/*.css', '**/*.scss',
+    ],
+    exclude: [
+        'node_modules/**', 'dist/**', 'build/**', '.git/**',
+        '*.min.js', '*.bundle.js', 'package-lock.json',
+        '.genesis/**', 'coverage/**', '.next/**',
+    ],
+    maxFileSize: 1024 * 1024, // 1MB
+    incremental: true,
+};
+// ============================================================================
+// Language Detection
+// ============================================================================
+const LANGUAGE_MAP = {
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.js': 'javascript',
+    '.jsx': 'javascript',
+    '.py': 'python',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.java': 'java',
+    '.md': 'markdown',
+    '.json': 'json',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.html': 'html',
+    '.css': 'css',
+    '.scss': 'scss',
+};
+function detectLanguage(filePath) {
+    const ext = path.extname(filePath).toLowerCase();
+    return LANGUAGE_MAP[ext] || 'text';
+}
+// ============================================================================
+// Symbol Extraction
+// ============================================================================
+function extractSymbols(content, language) {
+    const symbols = [];
+    // TypeScript/JavaScript
+    if (language === 'typescript' || language === 'javascript') {
+        // Functions
+        const funcMatches = content.matchAll(/(?:function|const|let|var)\s+(\w+)\s*(?:=\s*(?:async\s*)?\(|[\(:])/g);
+        for (const m of funcMatches)
+            symbols.push(m[1]);
+        // Classes
+        const classMatches = content.matchAll(/class\s+(\w+)/g);
+        for (const m of classMatches)
+            symbols.push(m[1]);
+        // Interfaces/Types
+        const typeMatches = content.matchAll(/(?:interface|type)\s+(\w+)/g);
+        for (const m of typeMatches)
+            symbols.push(m[1]);
+        // Exports
+        const exportMatches = content.matchAll(/export\s+(?:const|function|class|interface|type)\s+(\w+)/g);
+        for (const m of exportMatches)
+            symbols.push(m[1]);
+    }
+    // Python
+    if (language === 'python') {
+        const defMatches = content.matchAll(/def\s+(\w+)/g);
+        for (const m of defMatches)
+            symbols.push(m[1]);
+        const classMatches = content.matchAll(/class\s+(\w+)/g);
+        for (const m of classMatches)
+            symbols.push(m[1]);
+    }
+    // Go
+    if (language === 'go') {
+        const funcMatches = content.matchAll(/func\s+(?:\([^)]+\)\s+)?(\w+)/g);
+        for (const m of funcMatches)
+            symbols.push(m[1]);
+        const typeMatches = content.matchAll(/type\s+(\w+)/g);
+        for (const m of typeMatches)
+            symbols.push(m[1]);
+    }
+    return [...new Set(symbols)];
+}
+// ============================================================================
+// File Matching
+// ============================================================================
+function matchesPattern(filePath, pattern) {
+    // Convert glob to regex
+    const regex = pattern
+        .replace(/\./g, '\\.')
+        .replace(/\*\*/g, '{{GLOBSTAR}}')
+        .replace(/\*/g, '[^/]*')
+        .replace(/{{GLOBSTAR}}/g, '.*');
+    return new RegExp(`^${regex}$`).test(filePath);
+}
+function shouldIndex(filePath, config) {
+    const relative = path.relative(config.projectRoot, filePath);
+    // Check excludes first
+    for (const pattern of config.exclude) {
+        if (matchesPattern(relative, pattern))
+            return false;
+    }
+    // Check includes
+    for (const pattern of config.include) {
+        if (matchesPattern(relative, pattern))
+            return true;
+    }
+    return false;
+}
+// ============================================================================
+// Project Indexer Class
+// ============================================================================
+class ProjectIndexer {
+    config;
+    index = new Map();
+    trigramIndex = new Map();
+    constructor(config) {
+        this.config = { ...DEFAULT_CONFIG, ...config };
+        this.loadIndex();
+    }
+    // ==========================================================================
+    // Index Management
+    // ==========================================================================
+    /**
+     * Load existing index from disk
+     */
+    loadIndex() {
+        try {
+            if (fs.existsSync(this.config.indexPath)) {
+                const raw = fs.readFileSync(this.config.indexPath, 'utf-8');
+                const data = JSON.parse(raw);
+                this.index = new Map(Object.entries(data.files || {}));
+                this.rebuildTrigramIndex();
+            }
+        }
+        catch {
+            this.index = new Map();
+        }
+    }
+    /**
+     * Save index to disk
+     */
+    saveIndex() {
+        try {
+            const dir = path.dirname(this.config.indexPath);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+            fs.writeFileSync(this.config.indexPath, JSON.stringify({
+                files: Object.fromEntries(this.index),
+                lastIndexed: Date.now(),
+            }, null, 2));
+        }
+        catch (e) {
+            console.error('[Indexer] Failed to save:', e);
+        }
+    }
+    /**
+     * Build trigram index for fast search
+     */
+    rebuildTrigramIndex() {
+        this.trigramIndex.clear();
+        for (const [filePath, file] of this.index) {
+            const content = file.content.toLowerCase();
+            for (let i = 0; i < content.length - 2; i++) {
+                const trigram = content.slice(i, i + 3);
+                if (!this.trigramIndex.has(trigram)) {
+                    this.trigramIndex.set(trigram, new Set());
+                }
+                this.trigramIndex.get(trigram).add(filePath);
+            }
+        }
+    }
+    /**
+     * Index the entire project
+     */
+    async indexProject() {
+        console.log(`[Indexer] Indexing project: ${this.config.projectRoot}`);
+        const startTime = Date.now();
+        const files = this.walkDirectory(this.config.projectRoot);
+        let indexed = 0;
+        let skipped = 0;
+        for (const filePath of files) {
+            if (!shouldIndex(filePath, this.config)) {
+                skipped++;
+                continue;
+            }
+            try {
+                const stats = fs.statSync(filePath);
+                // Skip large files
+                if (stats.size > this.config.maxFileSize) {
+                    skipped++;
+                    continue;
+                }
+                // Check if file changed (incremental)
+                if (this.config.incremental) {
+                    const existing = this.index.get(filePath);
+                    if (existing && existing.mtime === stats.mtimeMs) {
+                        continue; // Skip unchanged
+                    }
+                }
+                // Index file
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const hash = crypto.createHash('sha256').update(content).digest('hex').slice(0, 16);
+                const language = detectLanguage(filePath);
+                const indexedFile = {
+                    path: path.relative(this.config.projectRoot, filePath),
+                    content,
+                    hash,
+                    size: stats.size,
+                    mtime: stats.mtimeMs,
+                    language,
+                    lines: content.split('\n').length,
+                    symbols: extractSymbols(content, language),
+                };
+                this.index.set(filePath, indexedFile);
+                indexed++;
+            }
+            catch (e) {
+                // Skip unreadable files
+                skipped++;
+            }
+        }
+        this.rebuildTrigramIndex();
+        this.saveIndex();
+        const duration = Date.now() - startTime;
+        console.log(`[Indexer] Indexed ${indexed} files, skipped ${skipped} in ${duration}ms`);
+        return this.stats();
+    }
+    /**
+     * Walk directory recursively
+     */
+    walkDirectory(dir) {
+        const files = [];
+        try {
+            const entries = fs.readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const fullPath = path.join(dir, entry.name);
+                // Skip hidden directories and common exclusions
+                if (entry.name.startsWith('.') && entry.isDirectory())
+                    continue;
+                if (entry.name === 'node_modules')
+                    continue;
+                if (entry.isDirectory()) {
+                    files.push(...this.walkDirectory(fullPath));
+                }
+                else if (entry.isFile()) {
+                    files.push(fullPath);
+                }
+            }
+        }
+        catch {
+            // Skip unreadable directories
+        }
+        return files;
+    }
+    // ==========================================================================
+    // Search
+    // ==========================================================================
+    /**
+     * Search for a string in the codebase
+     */
+    search(query, options = {}) {
+        const { limit = 20, caseSensitive = false } = options;
+        const results = [];
+        // Use trigram index for candidate files
+        const candidates = this.findCandidates(query.toLowerCase());
+        for (const filePath of candidates) {
+            const file = this.index.get(filePath);
+            if (!file)
+                continue;
+            const matches = this.findMatches(file.content, query, caseSensitive);
+            if (matches.length > 0) {
+                results.push({
+                    path: file.path,
+                    matches,
+                    score: matches.length,
+                });
+            }
+        }
+        // Sort by score and limit
+        return results
+            .sort((a, b) => b.score - a.score)
+            .slice(0, limit);
+    }
+    /**
+     * Find candidate files using trigram index
+     */
+    findCandidates(query) {
+        if (query.length < 3) {
+            // For short queries, check all files
+            return new Set(this.index.keys());
+        }
+        const trigrams = [];
+        for (let i = 0; i < query.length - 2; i++) {
+            trigrams.push(query.slice(i, i + 3));
+        }
+        // Files must contain all trigrams
+        let candidates = new Set();
+        let first = true;
+        for (const trigram of trigrams) {
+            const files = this.trigramIndex.get(trigram);
+            if (!files)
+                return new Set(); // No matches
+            if (first) {
+                candidates = new Set(files);
+                first = false;
+            }
+            else {
+                // Intersection - keep only candidates that are also in files
+                const intersection = new Set();
+                for (const f of candidates) {
+                    if (files.has(f)) {
+                        intersection.add(f);
+                    }
+                }
+                candidates = intersection;
+            }
+        }
+        return candidates || new Set();
+    }
+    /**
+     * Find matches in file content
+     */
+    findMatches(content, query, caseSensitive) {
+        const matches = [];
+        const lines = content.split('\n');
+        const searchQuery = caseSensitive ? query : query.toLowerCase();
+        for (let i = 0; i < lines.length; i++) {
+            const line = caseSensitive ? lines[i] : lines[i].toLowerCase();
+            if (line.includes(searchQuery)) {
+                // Get context (2 lines before and after)
+                const context = [];
+                for (let j = Math.max(0, i - 2); j <= Math.min(lines.length - 1, i + 2); j++) {
+                    if (j !== i)
+                        context.push(lines[j]);
+                }
+                matches.push({
+                    line: i + 1,
+                    content: lines[i],
+                    context,
+                });
+            }
+        }
+        return matches;
+    }
+    /**
+     * Search for a symbol (function, class, etc.)
+     */
+    searchSymbol(symbol) {
+        const results = [];
+        for (const [filePath, file] of this.index) {
+            if (file.symbols.some(s => s.toLowerCase().includes(symbol.toLowerCase()))) {
+                results.push({
+                    path: file.path,
+                    matches: [{
+                            line: 0,
+                            content: `Symbol: ${file.symbols.filter(s => s.toLowerCase().includes(symbol.toLowerCase())).join(', ')}`,
+                            context: [],
+                        }],
+                    score: 10,
+                });
+            }
+        }
+        return results;
+    }
+    /**
+     * Get file content
+     */
+    getFile(filePath) {
+        const absolute = path.isAbsolute(filePath)
+            ? filePath
+            : path.join(this.config.projectRoot, filePath);
+        return this.index.get(absolute) || null;
+    }
+    /**
+     * List all indexed files
+     */
+    listFiles() {
+        return Array.from(this.index.values()).map(f => f.path);
+    }
+    /**
+     * Get index statistics
+     */
+    stats() {
+        let totalLines = 0;
+        let totalBytes = 0;
+        const languages = {};
+        for (const file of this.index.values()) {
+            totalLines += file.lines;
+            totalBytes += file.size;
+            languages[file.language] = (languages[file.language] || 0) + 1;
+        }
+        return {
+            totalFiles: this.index.size,
+            totalLines,
+            totalBytes,
+            languages,
+            lastIndexed: Date.now(),
+            indexPath: this.config.indexPath,
+        };
+    }
+    /**
+     * Clear the index
+     */
+    clear() {
+        this.index.clear();
+        this.trigramIndex.clear();
+        this.saveIndex();
+    }
+}
+exports.ProjectIndexer = ProjectIndexer;
+// ============================================================================
+// Singleton
+// ============================================================================
+let indexerInstance = null;
+function getProjectIndexer(config) {
+    if (!indexerInstance) {
+        indexerInstance = new ProjectIndexer(config);
+    }
+    return indexerInstance;
+}
+function resetProjectIndexer() {
+    indexerInstance = null;
+}

package/dist/src/memory/procedural.d.ts

@@ -0,0 +1,136 @@
+/**
+ * Genesis 6.0 - Procedural Memory Store
+ *
+ * Stores skills and workflows - know-how.
+ * "How to do things"
+ *
+ * Key features:
+ * - Step-by-step procedures
+ * - Success rate tracking
+ * - Skill improvement over time
+ * - Prerequisites and dependencies
+ *
+ * Reference: Anderson, J. R. (1982). Acquisition of cognitive skill.
+ */
+import { ProceduralMemory, ParameterDef, IMemoryStore, MemoryFilter, StoreStats } from './types.js';
+export interface ProceduralStoreConfig {
+    maxSize: number;
+    autoForget: boolean;
+    forgetThreshold: number;
+    minSuccessRate: number;
+}
+export interface CreateProceduralOptions {
+    name: string;
+    description: string;
+    steps: Array<{
+        action: string;
+        params?: Record<string, any>;
+        condition?: string;
+        fallback?: string;
+    }>;
+    requires?: string[];
+    inputs?: ParameterDef[];
+    outputs?: ParameterDef[];
+    importance?: number;
+    tags?: string[];
+    associations?: string[];
+    source?: string;
+}
+export interface ExecutionResult {
+    success: boolean;
+    duration: number;
+    stepResults?: Array<{
+        step: number;
+        success: boolean;
+        error?: string;
+    }>;
+    error?: string;
+}
+export declare class ProceduralStore implements IMemoryStore<ProceduralMemory> {
+    private memories;
+    private config;
+    private byName;
+    private byTag;
+    private dependencies;
+    constructor(config?: Partial<ProceduralStoreConfig>);
+    store(input: Omit<ProceduralMemory, 'id' | 'created' | 'lastAccessed' | 'accessCount'>): ProceduralMemory;
+    /**
+     * Convenience method to create a procedural memory from options
+     */
+    createSkill(options: CreateProceduralOptions): ProceduralMemory;
+    /**
+     * Improve an existing skill with new information
+     */
+    private improveSkill;
+    get(id: string): ProceduralMemory | undefined;
+    /**
+     * Get by skill name
+     */
+    getByName(name: string): ProceduralMemory | undefined;
+    /**
+     * Get without updating access (for internal use)
+     */
+    peek(id: string): ProceduralMemory | undefined;
+    update(id: string, updates: Partial<ProceduralMemory>): ProceduralMemory | undefined;
+    delete(id: string): boolean;
+    query(filter: MemoryFilter<ProceduralMemory>): ProceduralMemory[];
+    /**
+     * Search by keyword in name and description
+     */
+    search(queryStr: string, limit?: number): ProceduralMemory[];
+    /**
+     * Record execution of a skill
+     */
+    recordExecution(id: string, result: ExecutionResult): void;
+    /**
+     * Get skills that need practice (low success rate or retention)
+     */
+    getSkillsNeedingPractice(): ProceduralMemory[];
+    /**
+     * Get mastered skills (high success rate and retention)
+     */
+    getMasteredSkills(): ProceduralMemory[];
+    /**
+     * Get prerequisites for a skill
+     */
+    getPrerequisites(id: string): ProceduralMemory[];
+    /**
+     * Get skills that depend on this skill
+     */
+    getDependents(id: string): ProceduralMemory[];
+    /**
+     * Check if all prerequisites are met for a skill
+     */
+    canExecute(id: string, minSuccessRate?: number): boolean;
+    getAll(): ProceduralMemory[];
+    clear(): void;
+    count(): number;
+    stats(): StoreStats;
+    /**
+     * Get additional procedural-specific stats
+     */
+    proceduralStats(): {
+        totalSkills: number;
+        mastered: number;
+        needsPractice: number;
+        avgSuccessRate: number;
+        avgExecutions: number;
+        mostUsed: ProceduralMemory[];
+    };
+    /**
+     * Get skills that should be forgotten (low retention AND low success)
+     */
+    getForgotten(): ProceduralMemory[];
+    /**
+     * Run forgetting cycle
+     */
+    runForgetting(): {
+        forgotten: number;
+        ids: string[];
+    };
+    private accessMemory;
+    private updateIndexes;
+    private removeFromIndexes;
+    private maintainSize;
+}
+export declare function createProceduralStore(config?: Partial<ProceduralStoreConfig>): ProceduralStore;