pikakit 2.0.0 → 3.0.0

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

@@ -0,0 +1,255 @@
+#!/usr/bin/env node
+/**
+ * Smart Learning Script - ESM Version (Production-Ready)
+ * 
+ * The "Teacher" script. Adds new lessons to the system memory.
+ * 
+ * Features:
+ * - Manual lesson addition
+ * - Category tagging
+ * - Source tracking (manual, eslint, test-failure)
+ * 
+ * Usage:
+ *   agent learn --add --pattern "regex" --message "why bad"
+ *   agent learn --list
+ *   agent learn --remove <id>
+ */
+
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { KNOWLEDGE_DIR, LESSONS_PATH, DEBUG, VERSION } from "./config.js";
+
+// ============================================================================
+// CORE FUNCTIONS
+// ============================================================================
+
+/**
+ * Load knowledge base from YAML file
+ * @returns {{ lessons: Array, version?: number }}
+ */
+function loadKnowledge() {
+    try {
+        if (!fs.existsSync(LESSONS_PATH)) {
+            const initial = { lessons: [], version: 1 };
+            fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+            fs.writeFileSync(LESSONS_PATH, yaml.dump(initial), "utf8");
+            return initial;
+        }
+        const content = fs.readFileSync(LESSONS_PATH, "utf8");
+        return yaml.load(content) || { lessons: [], version: 1 };
+    } catch (error) {
+        console.error("❌ Failed to load knowledge base:", error.message);
+        if (DEBUG) console.error(error.stack);
+        process.exit(1);
+    }
+}
+
+/**
+ * Save knowledge base to YAML file
+ * @param {{ lessons: Array, version?: number }} data
+ */
+function saveKnowledge(data) {
+    try {
+        fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+        const str = yaml.dump(data, { lineWidth: -1, quotingType: '"' });
+        fs.writeFileSync(LESSONS_PATH, str, "utf8");
+        console.log("✅ Knowledge base updated successfully.");
+    } catch (error) {
+        console.error("❌ Failed to save knowledge base:", error.message);
+        if (DEBUG) console.error(error.stack);
+        process.exit(1);
+    }
+}
+
+/**
+ * Add a new lesson to the knowledge base
+ * @param {string} pattern - Regex pattern
+ * @param {string} message - Explanation message
+ * @param {string} severity - WARNING or ERROR
+ * @param {string} category - Category tag
+ */
+function addLesson(pattern, message, severity = "WARNING", category = "general") {
+    const db = loadKnowledge();
+
+    // Validate Regex
+    try {
+        new RegExp(pattern);
+    } catch (e) {
+        console.error("❌ Invalid Regex pattern:", e.message);
+        process.exit(1);
+    }
+
+    // Validate severity
+    if (!["WARNING", "ERROR"].includes(severity.toUpperCase())) {
+        console.error("❌ Invalid severity. Must be WARNING or ERROR");
+        process.exit(1);
+    }
+
+    // Check for duplicates
+    const exists = db.lessons.some(l => l.pattern === pattern);
+    if (exists) {
+        console.log("⚠️  Pattern already exists in knowledge base.");
+        process.exit(0);
+    }
+
+    const id = `LEARN-${String(db.lessons.length + 1).padStart(3, "0")}`;
+
+    const lesson = {
+        id,
+        pattern,
+        message,
+        severity: severity.toUpperCase(),
+        category,
+        source: "manual",
+        hitCount: 0,
+        lastHit: null,
+        autoEscalated: false,
+        addedAt: new Date().toISOString()
+    };
+
+    db.lessons.push(lesson);
+    saveKnowledge(db);
+
+    console.log(`\n🎓 Lesson Learned: [${id}]`);
+    console.log(`   Pattern:  /${pattern}/`);
+    console.log(`   Message:  ${message}`);
+    console.log(`   Severity: ${severity.toUpperCase()}`);
+    console.log(`   Category: ${category}\n`);
+}
+
+/**
+ * Remove a lesson by ID
+ * @param {string} lessonId 
+ */
+function removeLesson(lessonId) {
+    const db = loadKnowledge();
+    const idx = db.lessons.findIndex(l => l.id === lessonId.toUpperCase());
+
+    if (idx === -1) {
+        console.log(`❌ Lesson not found: ${lessonId}`);
+        process.exit(1);
+    }
+
+    const removed = db.lessons.splice(idx, 1)[0];
+    saveKnowledge(db);
+
+    console.log(`\n🗑️  Removed lesson: [${removed.id}]`);
+    console.log(`   Pattern: /${removed.pattern}/\n`);
+}
+
+/**
+ * List all learned lessons
+ * @param {string} category - Filter by category
+ */
+function listLessons(category = null) {
+    const db = loadKnowledge();
+
+    if (!db.lessons || db.lessons.length === 0) {
+        console.log("\nℹ️  No lessons learned yet.");
+        console.log("   Use: agent learn --add --pattern \"pat\" --message \"msg\"\n");
+        return;
+    }
+
+    let lessons = db.lessons;
+    if (category) {
+        lessons = lessons.filter(l => l.category === category);
+    }
+
+    console.log(`\n🧠 PikaKit Knowledge Base (${lessons.length} lesson(s))\n`);
+    console.log("─".repeat(60));
+
+    lessons.forEach(l => {
+        const icon = l.severity === "ERROR" ? "❌" : "⚠️";
+        const hits = l.hitCount ? ` (${l.hitCount} hits)` : "";
+        const escalated = l.autoEscalated ? " ⚡" : "";
+
+        console.log(`${icon} [${l.id}] ${l.message}${hits}${escalated}`);
+        console.log(`   Pattern: /${l.pattern}/`);
+        console.log(`   Category: ${l.category || "general"} | Source: ${l.source || "manual"}`);
+        console.log("");
+    });
+}
+
+// ============================================================================
+// CLI
+// ============================================================================
+
+function printHelp() {
+    console.log(`
+🎓 Smart Learning Tool v${VERSION}
+
+USAGE:
+  agent learn --add --pattern "..." --message "..."
+  agent learn --list [--category <cat>]
+  agent learn --remove <ID>
+
+OPTIONS:
+  --add         Add a new lesson
+  --pattern     Regex pattern to flag
+  --message     Explanation message
+  --severity    WARNING (default) or ERROR
+  --category    Category tag (default: general)
+  --list        List all lessons
+  --remove      Remove lesson by ID
+  --help        Show this help
+
+EXAMPLES:
+  agent learn --add --pattern "console\\.log" --message "No console.log in production" --severity ERROR
+  agent learn --list
+  agent learn --remove LEARN-001
+`);
+}
+
+function main() {
+    const args = process.argv.slice(2);
+
+    if (args.includes("--help") || args.length === 0) {
+        printHelp();
+        process.exit(0);
+    }
+
+    if (args.includes("--list")) {
+        const catIdx = args.indexOf("--category");
+        const category = catIdx !== -1 ? args[catIdx + 1] : null;
+        listLessons(category);
+        process.exit(0);
+    }
+
+    if (args.includes("--remove")) {
+        const removeIdx = args.indexOf("--remove");
+        const lessonId = args[removeIdx + 1];
+        if (!lessonId) {
+            console.error("❌ Missing lesson ID for --remove");
+            process.exit(1);
+        }
+        removeLesson(lessonId);
+        process.exit(0);
+    }
+
+    if (args.includes("--add")) {
+        const pIdx = args.indexOf("--pattern");
+        const mIdx = args.indexOf("--message");
+        const sIdx = args.indexOf("--severity");
+        const cIdx = args.indexOf("--category");
+
+        if (pIdx === -1 || mIdx === -1) {
+            console.error("❌ --pattern and --message are required for --add");
+            process.exit(1);
+        }
+
+        const pattern = args[pIdx + 1];
+        const message = args[mIdx + 1];
+        const severity = sIdx !== -1 ? args[sIdx + 1] : "WARNING";
+        const category = cIdx !== -1 ? args[cIdx + 1] : "general";
+
+        if (!pattern || !message) {
+            console.error("❌ Missing values for pattern/message");
+            process.exit(1);
+        }
+
+        addLesson(pattern, message, severity, category);
+    }
+}
+
+main();

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

@@ -0,0 +1,70 @@
+/**
+ * @fileoverview Tests for learn.js functionality
+ */
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// Mock config để test
+const TEST_DIR = path.join(os.tmpdir(), "agent-skill-kit-test");
+const KNOWLEDGE_DIR = path.join(TEST_DIR, ".agent", "knowledge");
+const LESSONS_PATH = path.join(KNOWLEDGE_DIR, "lessons-learned.yaml");
+
+describe("Knowledge Base Operations", () => {
+    beforeEach(() => {
+        fs.mkdirSync(KNOWLEDGE_DIR, { recursive: true });
+    });
+
+    afterEach(() => {
+        fs.rmSync(TEST_DIR, { recursive: true, force: true });
+    });
+
+    it("creates initial knowledge file if missing", () => {
+        // Simulate missing file scenario
+        expect(fs.existsSync(LESSONS_PATH)).toBe(false);
+
+        // Create initial file
+        const initial = { lessons: [] };
+        fs.writeFileSync(LESSONS_PATH, JSON.stringify(initial), "utf8");
+
+        expect(fs.existsSync(LESSONS_PATH)).toBe(true);
+    });
+
+    it("can write and read lessons", () => {
+        const lesson = {
+            id: "LEARN-001",
+            pattern: "console\\.log",
+            message: "No console.log in production",
+            severity: "WARNING",
+            addedAt: new Date().toISOString()
+        };
+
+        const data = { lessons: [lesson] };
+        fs.writeFileSync(LESSONS_PATH, JSON.stringify(data), "utf8");
+
+        const content = fs.readFileSync(LESSONS_PATH, "utf8");
+        const parsed = JSON.parse(content);
+
+        expect(parsed.lessons).toHaveLength(1);
+        expect(parsed.lessons[0].id).toBe("LEARN-001");
+        expect(parsed.lessons[0].pattern).toBe("console\\.log");
+    });
+
+    it("validates regex patterns", () => {
+        const validPattern = "console\\.log";
+        const invalidPattern = "[invalid(";
+
+        expect(() => new RegExp(validPattern)).not.toThrow();
+        expect(() => new RegExp(invalidPattern)).toThrow();
+    });
+
+    it("validates severity values", () => {
+        const validSeverities = ["WARNING", "ERROR"];
+        const invalidSeverity = "INFO";
+
+        expect(validSeverities.includes("WARNING")).toBe(true);
+        expect(validSeverities.includes("ERROR")).toBe(true);
+        expect(validSeverities.includes(invalidSeverity)).toBe(false);
+    });
+});

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

@@ -0,0 +1,199 @@
+/**
+ * @fileoverview Proposal Generator for Auto-Updating Flow
+ * Generates markdown instructions for AI agents to update skills
+ */
+
+import fs from "fs";
+import path from "path";
+import yaml from "js-yaml";
+import { KNOWLEDGE_DIR, LESSONS_PATH, AGENT_DIR } from "./config.js";
+import { loadSettings } from "./settings.js";
+import { loadKnowledge } from "./recall.js";
+
+/** Proposals directory */
+const PROPOSALS_DIR = path.join(KNOWLEDGE_DIR, "proposals");
+
+/** Dismissed proposals file */
+const DISMISSED_FILE = path.join(PROPOSALS_DIR, "dismissed.yaml");
+
+/**
+ * Get lessons that qualify for proposals (hitCount >= threshold)
+ * @returns {Array<{ lesson: object, proposalPath: string }>}
+ */
+export function getQualifyingLessons() {
+    const settings = loadSettings();
+    const threshold = settings.updateThreshold || 5;
+    const db = loadKnowledge();
+
+    if (!db.lessons) return [];
+
+    const dismissed = loadDismissed();
+
+    return db.lessons
+        .filter(l => (l.hitCount || 0) >= threshold && !dismissed.has(l.id))
+        .map(lesson => ({
+            lesson,
+            proposalPath: path.join(PROPOSALS_DIR, `${lesson.id}.md`)
+        }));
+}
+
+/**
+ * Load dismissed proposal IDs
+ * @returns {Set<string>}
+ */
+function loadDismissed() {
+    try {
+        if (fs.existsSync(DISMISSED_FILE)) {
+            const data = yaml.load(fs.readFileSync(DISMISSED_FILE, "utf8")) || {};
+            return new Set(data.dismissed || []);
+        }
+    } catch (e) { }
+    return new Set();
+}
+
+/**
+ * Dismiss a proposal
+ * @param {string} lessonId
+ */
+export function dismissProposal(lessonId) {
+    fs.mkdirSync(PROPOSALS_DIR, { recursive: true });
+    const dismissed = loadDismissed();
+    dismissed.add(lessonId);
+    fs.writeFileSync(DISMISSED_FILE, yaml.dump({ dismissed: [...dismissed] }), "utf8");
+}
+
+/**
+ * Generate proposal markdown for AI agent
+ * @param {object} lesson - Lesson object
+ * @returns {string} Markdown content
+ */
+export function generateProposalMarkdown(lesson) {
+    const skillHint = guessSkillFromLesson(lesson);
+
+    return `# 🤖 Skill Update Proposal
+
+## Pattern Detected
+| Field | Value |
+|-------|-------|
+| **ID** | \`${lesson.id}\` |
+| **Hit Count** | ${lesson.hitCount || 0} |
+| **Severity** | ${lesson.severity || "WARNING"} |
+| **Last Hit** | ${lesson.lastHit || "N/A"} |
+
+## Message
+> ${lesson.message}
+
+## Pattern (Regex)
+\`\`\`
+${lesson.pattern}
+\`\`\`
+
+---
+
+## 📝 Suggested Action for AI Agent
+
+Please update the relevant skill file to include this rule:
+
+### Target File
+\`${skillHint}\`
+
+### Add to Rules Section
+\`\`\`markdown
+### ${lesson.message}
+- Pattern: \`${lesson.pattern}\`
+- Severity: ${lesson.severity || "WARNING"}
+- Auto-learned from violations
+\`\`\`
+
+---
+
+## How to Apply
+
+1. **Copy this entire proposal**
+2. **Paste to your AI coding agent** (Claude, Gemini, etc.)
+3. **Ask:** "Update the skill file with this rule"
+
+The AI agent will modify the appropriate \`.agent/skills/*/SKILL.md\` file.
+
+---
+
+*Generated by PikaKit v2.1.0*
+`;
+}
+
+/**
+ * Guess which skill file this lesson relates to
+ * @param {object} lesson
+ * @returns {string}
+ */
+function guessSkillFromLesson(lesson) {
+    const pattern = (lesson.pattern || "").toLowerCase();
+    const message = (lesson.message || "").toLowerCase();
+    const combined = pattern + " " + message;
+
+    // Frontend patterns
+    if (combined.includes("react") || combined.includes("component") || combined.includes("hook") || combined.includes("usestate") || combined.includes("useeffect")) {
+        return ".agent/skills/react-patterns/SKILL.md";
+    }
+    if (combined.includes("next") || combined.includes("getserverside") || combined.includes("getstaticprops") || combined.includes("app router")) {
+        return ".agent/skills/nextjs-best-practices/SKILL.md";
+    }
+    if (combined.includes("css") || combined.includes("style") || combined.includes("tailwind") || combined.includes("classname")) {
+        return ".agent/skills/frontend-design/SKILL.md";
+    }
+
+    // Backend patterns
+    if (combined.includes("api") || combined.includes("fetch") || combined.includes("http") || combined.includes("endpoint") || combined.includes("rest")) {
+        return ".agent/skills/api-patterns/SKILL.md";
+    }
+    if (combined.includes("database") || combined.includes("sql") || combined.includes("prisma") || combined.includes("query") || combined.includes("schema")) {
+        return ".agent/skills/database-design/SKILL.md";
+    }
+    if (combined.includes("node") || combined.includes("express") || combined.includes("server") || combined.includes("middleware")) {
+        return ".agent/skills/nodejs-best-practices/SKILL.md";
+    }
+
+    // Testing patterns
+    if (combined.includes("test") || combined.includes("mock") || combined.includes("jest") || combined.includes("vitest") || combined.includes("expect")) {
+        return ".agent/skills/testing-patterns/SKILL.md";
+    }
+
+    // TypeScript patterns
+    if (combined.includes("typescript") || combined.includes("type") || combined.includes("interface") || combined.includes("generic") || combined.includes("any")) {
+        return ".agent/skills/typescript-expert/SKILL.md";
+    }
+
+    // Security patterns
+    if (combined.includes("security") || combined.includes("auth") || combined.includes("password") || combined.includes("token") || combined.includes("xss") || combined.includes("injection")) {
+        return ".agent/skills/vulnerability-scanner/SKILL.md";
+    }
+
+    // Performance patterns
+    if (combined.includes("performance") || combined.includes("memo") || combined.includes("lazy") || combined.includes("cache") || combined.includes("optimize")) {
+        return ".agent/skills/performance-profiling/SKILL.md";
+    }
+
+    // Git patterns
+    if (combined.includes("commit") || combined.includes("branch") || combined.includes("merge") || combined.includes("git")) {
+        return ".agent/skills/git-conventions/SKILL.md";
+    }
+
+    // Default to clean-code for general patterns
+    return ".agent/skills/clean-code/SKILL.md";
+}
+
+/**
+ * Count pending proposals
+ * @returns {number}
+ */
+export function countPendingProposals() {
+    return getQualifyingLessons().length;
+}
+
+export default {
+    getQualifyingLessons,
+    dismissProposal,
+    generateProposalMarkdown,
+    countPendingProposals,
+    PROPOSALS_DIR
+};

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

@@ -0,0 +1,56 @@
+/**
+ * @fileoverview Tests for proposals module
+ */
+
+import { describe, it, expect } from "vitest";
+
+// Test proposal markdown generation without mocking
+describe("proposals", () => {
+    describe("generateProposalMarkdown format", () => {
+        it("creates markdown with required sections", () => {
+            const lesson = {
+                id: "LEARN-001",
+                pattern: "console\\.log",
+                message: "No console.log in production",
+                hitCount: 5,
+                severity: "ERROR"
+            };
+
+            // Simulate markdown generation
+            const md = `# 🤖 Skill Update Proposal\n\n## Pattern Detected\n| Field | Value |\n|-------|-------|\n| **ID** | \`${lesson.id}\` |\n| **Hit Count** | ${lesson.hitCount || 0} |\n\n## Message\n> ${lesson.message}`;
+
+            expect(md).toContain("LEARN-001");
+            expect(md).toContain("No console.log");
+            expect(md).toContain("5");
+        });
+
+        it("includes AI agent instructions", () => {
+            const md = `## How to Apply\n1. **Copy this entire proposal**\n2. **Paste to your AI coding agent**`;
+
+            expect(md).toContain("Copy");
+            expect(md).toContain("Paste");
+            expect(md).toContain("AI");
+        });
+    });
+
+    describe("proposal threshold", () => {
+        it("default threshold is 5", () => {
+            const defaultThreshold = 5;
+            expect(defaultThreshold).toBe(5);
+        });
+
+        it("lesson qualifies when hitCount >= threshold", () => {
+            const threshold = 5;
+            const lessons = [
+                { id: "L1", hitCount: 5 },
+                { id: "L2", hitCount: 3 },
+                { id: "L3", hitCount: 10 }
+            ];
+
+            const qualifying = lessons.filter(l => l.hitCount >= threshold);
+            expect(qualifying).toHaveLength(2);
+            expect(qualifying.map(l => l.id)).toContain("L1");
+            expect(qualifying.map(l => l.id)).toContain("L3");
+        });
+    });
+});