pikakit 3.0.5 → 3.7.2

package/lib/agent-cli/lib/ignore.js

@@ -1,116 +0,0 @@
-/**
- * @fileoverview Ignore patterns parser for PikaKit
- * Supports .agentignore file with glob patterns
- */
-
-import fs from "fs";
-import path from "path";
-import { cwd } from "./config.js";
-
-/** Default patterns always ignored */
-const DEFAULT_IGNORES = [
-    "node_modules/**",
-    ".git/**",
-    "dist/**",
-    "build/**",
-    ".next/**",
-    "coverage/**",
-    "*.log"
-];
-
-/**
- * Load ignore patterns from .agentignore file
- * @param {string} basePath - Base directory
- * @returns {string[]} Array of patterns
- */
-export function loadIgnorePatterns(basePath = cwd) {
-    const patterns = [...DEFAULT_IGNORES];
-    const ignoreFile = path.join(basePath, ".agentignore");
-
-    try {
-        if (fs.existsSync(ignoreFile)) {
-            const content = fs.readFileSync(ignoreFile, "utf8");
-            const lines = content.split("\n");
-
-            for (const line of lines) {
-                const trimmed = line.trim();
-                // Skip empty lines and comments
-                if (trimmed && !trimmed.startsWith("#")) {
-                    patterns.push(trimmed);
-                }
-            }
-        }
-    } catch (e) {
-        // Silently use defaults
-    }
-
-    return [...new Set(patterns)]; // Remove duplicates
-}
-
-/**
- * Check if a file path matches any ignore pattern
- * @param {string} filePath - Relative file path
- * @param {string[]} patterns - Ignore patterns
- * @returns {boolean}
- */
-export function isIgnored(filePath, patterns) {
-    const normalized = filePath.replace(/\\/g, "/");
-
-    for (const pattern of patterns) {
-        // Simple glob matching
-        const regex = patternToRegex(pattern);
-        if (regex.test(normalized)) {
-            return true;
-        }
-    }
-
-    return false;
-}
-
-/**
- * Convert glob pattern to regex
- * @param {string} pattern - Glob pattern
- * @returns {RegExp}
- */
-function patternToRegex(pattern) {
-    let regex = pattern
-        .replace(/\./g, "\\.")      // Escape dots
-        .replace(/\*\*/g, ".*")     // ** matches everything
-        .replace(/\*/g, "[^/]*")    // * matches segment
-        .replace(/\?/g, ".");       // ? matches single char
-
-    // Handle directory patterns (ending with /)
-    if (pattern.endsWith("/")) {
-        regex = regex.slice(0, -1) + "(/.*)?";
-    }
-
-    return new RegExp(`^${regex}$|/${regex}$|^${regex}/`);
-}
-
-/**
- * Filter files array by ignore patterns
- * @param {string[]} files - Array of file paths
- * @param {string[]} patterns - Ignore patterns
- * @returns {{ included: string[], ignored: number }}
- */
-export function filterFiles(files, patterns) {
-    const included = [];
-    let ignored = 0;
-
-    for (const file of files) {
-        if (isIgnored(file, patterns)) {
-            ignored++;
-        } else {
-            included.push(file);
-        }
-    }
-
-    return { included, ignored };
-}
-
-export default {
-    loadIgnorePatterns,
-    isIgnored,
-    filterFiles,
-    DEFAULT_IGNORES
-};

package/lib/agent-cli/lib/ignore.test.js

@@ -1,58 +0,0 @@
-/**
- * @fileoverview Tests for ignore module
- */
-
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
-import fs from "fs";
-import path from "path";
-import os from "os";
-
-// Import directly without mocking - test actual behavior
-import { loadIgnorePatterns, isIgnored } from "./ignore.js";
-
-describe("ignore", () => {
-    describe("isIgnored", () => {
-        it("returns false when no patterns", () => {
-            const result = isIgnored("some/path.js", []);
-            expect(result).toBe(false);
-        });
-
-        it("matches exact pattern", () => {
-            const result = isIgnored("node_modules/pkg/file.js", ["node_modules"]);
-            expect(result).toBe(true);
-        });
-
-        it("matches glob pattern", () => {
-            const result = isIgnored("debug.log", ["*.log"]);
-            expect(result).toBe(true);
-        });
-
-        it("returns false for non-matching path", () => {
-            const result = isIgnored("src/app.js", ["*.log", "node_modules"]);
-            expect(result).toBe(false);
-        });
-
-        it("matches directory pattern", () => {
-            const result = isIgnored("dist/bundle.js", ["dist/**"]);
-            expect(result).toBe(true);
-        });
-
-        it("matches nested paths", () => {
-            const result = isIgnored(".git/objects/pack", [".git/**"]);
-            expect(result).toBe(true);
-        });
-    });
-
-    describe("loadIgnorePatterns", () => {
-        it("returns array of patterns", () => {
-            const patterns = loadIgnorePatterns();
-            expect(Array.isArray(patterns)).toBe(true);
-        });
-
-        it("includes default patterns", () => {
-            const patterns = loadIgnorePatterns();
-            // Should have at least some patterns (defaults or from file)
-            expect(patterns.length).toBeGreaterThan(0);
-        });
-    });
-});

package/lib/agent-cli/lib/init.js

@@ -1,124 +0,0 @@
-/**
- * @fileoverview Project initialization wizard
- * Sets up agent config for new projects
- */
-
-import fs from "fs";
-import path from "path";
-import { cwd, AGENT_DIR, KNOWLEDGE_DIR, LESSONS_PATH } from "./config.js";
-
-/**
- * Detect project type based on files
- * @returns {string} Project type
- */
-export function detectProjectType() {
-    const files = fs.readdirSync(cwd);
-
-    if (files.includes("package.json")) {
-        const pkg = JSON.parse(fs.readFileSync(path.join(cwd, "package.json"), "utf8"));
-
-        if (pkg.dependencies?.next || pkg.devDependencies?.next) return "nextjs";
-        if (pkg.dependencies?.react || pkg.devDependencies?.react) return "react";
-        if (pkg.dependencies?.vue || pkg.devDependencies?.vue) return "vue";
-        if (pkg.dependencies?.express || pkg.devDependencies?.express) return "node";
-        return "node";
-    }
-
-    if (files.includes("requirements.txt") || files.includes("pyproject.toml")) return "python";
-    if (files.includes("Cargo.toml")) return "rust";
-    if (files.includes("go.mod")) return "go";
-    if (files.includes("pom.xml") || files.includes("build.gradle")) return "java";
-
-    return "generic";
-}
-
-/**
- * Get default ignore patterns for project type
- * @param {string} projectType 
- * @returns {string[]}
- */
-export function getDefaultIgnorePatterns(projectType) {
-    const common = [
-        "node_modules/**",
-        ".git/**",
-        "dist/**",
-        "build/**",
-        "coverage/**",
-        "*.log",
-        "*.lock",
-        ".env*"
-    ];
-
-    const specific = {
-        node: ["package-lock.json"],
-        nextjs: [".next/**", "out/**"],
-        react: ["build/**"],
-        vue: [".nuxt/**"],
-        python: ["__pycache__/**", "*.pyc", ".venv/**", "venv/**"],
-        rust: ["target/**"],
-        go: ["vendor/**"],
-        java: ["target/**", "*.class"],
-        generic: []
-    };
-
-    return [...common, ...(specific[projectType] || [])];
-}
-
-/**
- * Initialize agent config
- * @param {object} options
- * @param {boolean} options.force - Overwrite existing
- * @returns {{ success: boolean, message: string }}
- */
-export function initProject(options = {}) {
-    const { force = false } = options;
-
-    // Check if already initialized
-    if (fs.existsSync(KNOWLEDGE_DIR) && !force) {
-        return {
-            success: false,
-            message: "Already initialized. Use --force to reinitialize."
-        };
-    }
-
-    // Detect project type
-    const projectType = detectProjectType();
-
-    // Create directories
-    fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
-
-    // Create lessons-learned.yaml
-    if (!fs.existsSync(LESSONS_PATH)) {
-        const initialLessons = `# PikaKit - Lessons Learned
-# Project Type: ${projectType}
-# Created: ${new Date().toISOString()}
-
-lessons: []
-`;
-        fs.writeFileSync(LESSONS_PATH, initialLessons);
-    }
-
-    // Create .agentignore if not exists
-    const agentignorePath = path.join(cwd, ".agentignore");
-    if (!fs.existsSync(agentignorePath)) {
-        const patterns = getDefaultIgnorePatterns(projectType);
-        fs.writeFileSync(agentignorePath, patterns.join("\n") + "\n");
-    }
-
-    return {
-        success: true,
-        message: `Initialized for ${projectType} project`,
-        projectType,
-        paths: {
-            knowledge: KNOWLEDGE_DIR,
-            lessons: LESSONS_PATH,
-            agentignore: agentignorePath
-        }
-    };
-}
-
-export default {
-    detectProjectType,
-    getDefaultIgnorePatterns,
-    initProject
-};

package/lib/agent-cli/lib/knowledge-index.js

@@ -1,326 +0,0 @@
-#!/usr/bin/env node
-/**
- * Knowledge Index Generator
- * 
- * Builds inverted index for O(1) pattern lookup in knowledge base.
- * Regenerates on-demand when knowledge files change.
- * 
- * Usage:
- *   agent index --rebuild    # Force rebuild index
- *   agent index --status     # Check index freshness
- */
-
-import fs from 'fs';
-import path from 'path';
-import yaml from 'js-yaml';
-import { KNOWLEDGE_DIR } from './config.js';
-
-const INDEX_PATH = path.join(KNOWLEDGE_DIR, 'index.json');
-const INDEX_VERSION = 1;
-
-/**
- * Load all lessons from knowledge base
- * @returns {{ mistakes: Array, improvements: Array }}
- */
-function loadAllLessons() {
-    const mistakes = [];
-    const improvements = [];
-    
-    // Load mistakes.yaml
-    const mistakesPath = path.join(KNOWLEDGE_DIR, 'mistakes.yaml');
-    if (fs.existsSync(mistakesPath)) {
-        const data = yaml.load(fs.readFileSync(mistakesPath, 'utf8'));
-        if (data?.mistakes) {
-            mistakes.push(...data.mistakes.map(m => ({ ...m, type: 'mistake' })));
-        }
-    }
-    
-    // Load improvements.yaml
-    const improvementsPath = path.join(KNOWLEDGE_DIR, 'improvements.yaml');
-    if (fs.existsSync(improvementsPath)) {
-        const data = yaml.load(fs.readFileSync(improvementsPath, 'utf8'));
-        if (data?.improvements) {
-            improvements.push(...data.improvements.map(i => ({ ...i, type: 'improvement' })));
-        }
-    }
-    
-    return { mistakes, improvements };
-}
-
-/**
- * Build inverted index from lessons
- * @param {Array} lessons - All lessons combined
- * @returns {Object} Index structure
- */
-function buildIndex(lessons) {
-    const patternIndex = {};  // pattern word -> lesson IDs
-    const tagIndex = {};      // tag -> lesson IDs
-    const idIndex = {};       // id -> lesson (for direct lookup)
-    const severityIndex = {   // severity -> lesson IDs
-        ERROR: [],
-        WARNING: [],
-        INFO: []
-    };
-    
-    for (const lesson of lessons) {
-        const id = lesson.id;
-        
-        // ID index (direct lookup)
-        idIndex[id] = {
-            pattern: lesson.pattern,
-            message: lesson.message,
-            severity: lesson.severity || 'WARNING',
-            type: lesson.type,
-            hitCount: lesson.hitCount || 0,
-            confidence: lesson.cognitive?.confidence || 0.3
-        };
-        
-        // Pattern index (tokenize pattern for partial matching)
-        if (lesson.pattern) {
-            const tokens = tokenizePattern(lesson.pattern);
-            for (const token of tokens) {
-                if (!patternIndex[token]) {
-                    patternIndex[token] = [];
-                }
-                if (!patternIndex[token].includes(id)) {
-                    patternIndex[token].push(id);
-                }
-            }
-        }
-        
-        // Tag index
-        if (lesson.tags && Array.isArray(lesson.tags)) {
-            for (const tag of lesson.tags) {
-                if (!tagIndex[tag]) {
-                    tagIndex[tag] = [];
-                }
-                if (!tagIndex[tag].includes(id)) {
-                    tagIndex[tag].push(id);
-                }
-            }
-        }
-        
-        // Severity index
-        const severity = lesson.severity || 'WARNING';
-        if (severityIndex[severity]) {
-            severityIndex[severity].push(id);
-        }
-    }
-    
-    return {
-        version: INDEX_VERSION,
-        generatedAt: new Date().toISOString(),
-        stats: {
-            totalLessons: lessons.length,
-            totalMistakes: lessons.filter(l => l.type === 'mistake').length,
-            totalImprovements: lessons.filter(l => l.type === 'improvement').length,
-            totalPatterns: Object.keys(patternIndex).length,
-            totalTags: Object.keys(tagIndex).length
-        },
-        patternIndex,
-        tagIndex,
-        severityIndex,
-        idIndex
-    };
-}
-
-/**
- * Tokenize a regex pattern into searchable words
- * @param {string} pattern - Regex pattern
- * @returns {string[]} Tokens
- */
-function tokenizePattern(pattern) {
-    // Extract alphanumeric words, ignoring regex special chars
-    const words = pattern
-        .replace(/[\[\]\(\)\{\}\.\*\+\?\^\$\\|]/g, ' ')
-        .split(/\s+/)
-        .map(w => w.toLowerCase().trim())
-        .filter(w => w.length >= 2);
-    
-    return [...new Set(words)];
-}
-
-/**
- * Get modification time of knowledge files
- * @returns {number} Most recent mtime
- */
-function getKnowledgeMtime() {
-    const files = ['mistakes.yaml', 'improvements.yaml', 'lessons-learned.yaml'];
-    let maxMtime = 0;
-    
-    for (const file of files) {
-        const filepath = path.join(KNOWLEDGE_DIR, file);
-        if (fs.existsSync(filepath)) {
-            const stat = fs.statSync(filepath);
-            if (stat.mtime.getTime() > maxMtime) {
-                maxMtime = stat.mtime.getTime();
-            }
-        }
-    }
-    
-    return maxMtime;
-}
-
-/**
- * Check if index is stale
- * @returns {{ stale: boolean, reason?: string }}
- */
-export function checkIndexFreshness() {
-    if (!fs.existsSync(INDEX_PATH)) {
-        return { stale: true, reason: 'Index does not exist' };
-    }
-    
-    try {
-        const index = JSON.parse(fs.readFileSync(INDEX_PATH, 'utf8'));
-        const indexTime = new Date(index.generatedAt).getTime();
-        const knowledgeTime = getKnowledgeMtime();
-        
-        if (knowledgeTime > indexTime) {
-            return { stale: true, reason: 'Knowledge files modified after index' };
-        }
-        
-        if (index.version !== INDEX_VERSION) {
-            return { stale: true, reason: `Index version mismatch (${index.version} vs ${INDEX_VERSION})` };
-        }
-        
-        return { stale: false };
-    } catch (e) {
-        return { stale: true, reason: `Index corrupted: ${e.message}` };
-    }
-}
-
-/**
- * Load or rebuild index
- * @param {boolean} forceRebuild - Force rebuild even if fresh
- * @returns {Object} Index
- */
-export function loadIndex(forceRebuild = false) {
-    const freshness = checkIndexFreshness();
-    
-    if (!forceRebuild && !freshness.stale) {
-        // Load existing index
-        return JSON.parse(fs.readFileSync(INDEX_PATH, 'utf8'));
-    }
-    
-    // Rebuild index
-    return rebuildIndex();
-}
-
-/**
- * Force rebuild index
- * @returns {Object} New index
- */
-export function rebuildIndex() {
-    const { mistakes, improvements } = loadAllLessons();
-    const allLessons = [...mistakes, ...improvements];
-    
-    const index = buildIndex(allLessons);
-    
-    // Save index
-    fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
-    fs.writeFileSync(INDEX_PATH, JSON.stringify(index, null, 2), 'utf8');
-    
-    return index;
-}
-
-/**
- * Search index by pattern
- * @param {string} query - Search query
- * @param {Object} index - Loaded index
- * @returns {string[]} Matching lesson IDs
- */
-export function searchByPattern(query, index) {
-    const tokens = tokenizePattern(query);
-    const matchingIds = new Set();
-    
-    for (const token of tokens) {
-        if (index.patternIndex[token]) {
-            for (const id of index.patternIndex[token]) {
-                matchingIds.add(id);
-            }
-        }
-    }
-    
-    return [...matchingIds];
-}
-
-/**
- * Search index by tag
- * @param {string} tag - Tag to search
- * @param {Object} index - Loaded index
- * @returns {string[]} Matching lesson IDs
- */
-export function searchByTag(tag, index) {
-    return index.tagIndex[tag] || [];
-}
-
-/**
- * Get lesson by ID
- * @param {string} id - Lesson ID
- * @param {Object} index - Loaded index
- * @returns {Object|null} Lesson info
- */
-export function getById(id, index) {
-    return index.idIndex[id] || null;
-}
-
-/**
- * CLI entry point
- */
-function main() {
-    const args = process.argv.slice(2);
-    
-    if (args.includes('--status')) {
-        const freshness = checkIndexFreshness();
-        if (freshness.stale) {
-            console.log(`⚠️  Index is STALE: ${freshness.reason}`);
-            process.exit(1);
-        } else {
-            const index = loadIndex();
-            console.log(`✅ Index is FRESH`);
-            console.log(`   Generated: ${index.generatedAt}`);
-            console.log(`   Lessons: ${index.stats.totalLessons}`);
-            console.log(`   Patterns: ${index.stats.totalPatterns}`);
-            console.log(`   Tags: ${index.stats.totalTags}`);
-        }
-        return;
-    }
-    
-    if (args.includes('--rebuild')) {
-        console.log('🔄 Rebuilding knowledge index...');
-        const index = rebuildIndex();
-        console.log(`✅ Index rebuilt successfully`);
-        console.log(`   Lessons: ${index.stats.totalLessons}`);
-        console.log(`   Patterns: ${index.stats.totalPatterns}`);
-        console.log(`   Tags: ${index.stats.totalTags}`);
-        return;
-    }
-    
-    console.log(`
-📇 Knowledge Index Manager
-
-Usage:
-  agent index --rebuild    Rebuild index from knowledge files
-  agent index --status     Check if index is fresh or stale
-
-The index provides O(1) lookup for:
-  - Pattern matching (by keyword)
-  - Tag filtering
-  - Severity grouping
-  - Direct ID lookup
-`);
-}
-
-// Run if called directly
-if (process.argv[1]?.includes('knowledge-index')) {
-    main();
-}
-
-export default {
-    loadIndex,
-    rebuildIndex,
-    checkIndexFreshness,
-    searchByPattern,
-    searchByTag,
-    getById
-};