pikakit 3.0.5 → 3.7.2

package/README.md

@@ -159,7 +159,7 @@ npx pikakit add pikakit-agent-skills --force
 ├── WORKFLOW_CHAINS.md             # Workflow Patterns
 │
 ├── skills/                        # 50 Skills
-│   ├── auto-learner/
+│   ├── skill-generator/
 │   ├── react-architect/
 │   ├── typescript-expert/
 │   ├── debug-pro/

package/bin/lib/commands/install.js

@@ -1,4 +1,4 @@
-/**
+/**
  * @fileoverview Install command - Interactive skill installation
  */
 
@@ -12,7 +12,7 @@ import boxen from "boxen";
 import { parseSkillSpec, merkleHash } from "../helpers.js";
 import { parseSkillMdFrontmatter } from "../skills.js";
 import { step, activeStep, stepLine, S, c, fatal, spinner, multiselect, select, confirm, isCancel, cancel } from "../ui.js";
-import { WORKSPACE, GLOBAL_DIR, OFFLINE, GLOBAL, REPO_CACHE_DIR, CACHE_TTL_MS, FORCE_REFRESH } from "../config.js";
+import { WORKSPACE, GLOBAL_DIR, OFFLINE, GLOBAL } from "../config.js";
 import { installSkill } from "../installer.js";
 
 /**
@@ -47,90 +47,31 @@ export async function run(spec) {
     step("Source: " + c.cyan(url));
 
     const s = spinner();
-    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "add-skill-"));
-
-    // --- Repository Caching Logic ---
-    const cacheDir = path.join(REPO_CACHE_DIR, org, repo);
-    const cacheMetaFile = path.join(cacheDir, ".cache-meta.json");
-    let useCache = false;
-    let cacheHit = false;
+    s.start("Cloning repository");
 
-    // Check if cache exists and is valid
-    if (!FORCE_REFRESH && fs.existsSync(cacheDir) && fs.existsSync(cacheMetaFile)) {
-        try {
-            const meta = JSON.parse(fs.readFileSync(cacheMetaFile, "utf-8"));
-            const cacheAge = Date.now() - new Date(meta.timestamp).getTime();
-
-            if (cacheAge < CACHE_TTL_MS) {
-                useCache = true;
-                cacheHit = true;
-                s.start("Deploying next-generation skills...");
-            }
-        } catch {
-            // Invalid cache, will refresh
-        }
-    }
+    const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "add-skill-"));
 
-    let lastError = null;
+    // Retry logic with exponential backoff
     const MAX_RETRIES = 3;
+    let lastError = null;
 
-    if (useCache) {
-        // Fast path: Update cache with git fetch (much faster than clone)
+    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
         try {
-            await execAsync(`git -C "${cacheDir}" fetch --depth=1 origin HEAD`, { timeout: 30000 });
-            await execAsync(`git -C "${cacheDir}" reset --hard FETCH_HEAD`, { timeout: 10000 });
-
-            // Copy from cache to tmp
-            await fs.promises.cp(cacheDir, tmp, { recursive: true });
-
-            // Update cache metadata
-            fs.writeFileSync(cacheMetaFile, JSON.stringify({
-                timestamp: new Date().toISOString(),
-                org, repo, ref: ref || "HEAD"
-            }));
-
-            s.stop("Skills deployed successfully");
+            await execAsync(`git clone --depth=1 ${url} "${tmp}"`, { timeout: 60000 });
+            if (ref) await execAsync(`git -C "${tmp}" checkout ${ref}`, { timeout: 30000 });
+            lastError = null;
+            break;
         } catch (err) {
-            // Cache update failed, fall back to fresh clone
-            useCache = false;
-            cacheHit = false;
-        }
-    }
+            lastError = err;
 
-    if (!useCache) {
-        // Fresh clone with retry logic
-        s.start(FORCE_REFRESH ? "Force refreshing repository..." : "Deploying next-generation skills...");
+            if (attempt < MAX_RETRIES) {
+                const delay = Math.pow(2, attempt) * 1000; // 2s, 4s
+                s.message(`Retry ${attempt}/${MAX_RETRIES} in ${delay / 1000}s...`);
+                await new Promise(r => setTimeout(r, delay));
 
-        for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-            try {
-                await execAsync(`git clone --depth=1 ${url} "${tmp}"`, { timeout: 60000 });
-                if (ref) await execAsync(`git -C "${tmp}" checkout ${ref}`, { timeout: 30000 });
-                lastError = null;
-
-                // Save to cache for next time
-                try {
-                    fs.mkdirSync(path.dirname(cacheDir), { recursive: true });
-                    if (fs.existsSync(cacheDir)) fs.rmSync(cacheDir, { recursive: true, force: true });
-                    await fs.promises.cp(tmp, cacheDir, { recursive: true });
-                    fs.writeFileSync(path.join(cacheDir, ".cache-meta.json"), JSON.stringify({
-                        timestamp: new Date().toISOString(),
-                        org, repo, ref: ref || "HEAD"
-                    }));
-                } catch { /* Cache write failed, non-fatal */ }
-
-                break;
-            } catch (err) {
-                lastError = err;
-
-                if (attempt < MAX_RETRIES) {
-                    const delay = Math.pow(2, attempt) * 1000; // 2s, 4s
-                    s.message(`Retry ${attempt}/${MAX_RETRIES} in ${delay / 1000}s...`);
-                    await new Promise(r => setTimeout(r, delay));
-
-                    // Clean up failed attempt
-                    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { }
-                    fs.mkdirSync(tmp, { recursive: true });
-                }
+                // Clean up failed attempt
+                try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { }
+                fs.mkdirSync(tmp, { recursive: true });
             }
         }
     }
@@ -158,9 +99,7 @@ export async function run(spec) {
         return;
     }
 
-    if (!cacheHit) {
-        s.stop("Skills deployed successfully");
-    }
+    s.stop("Repository cloned");
 
     // Find skills in repo - check multiple possible locations
     const skillsInRepo = [];
@@ -282,11 +221,11 @@ export async function run(spec) {
                     return category;
                 }
             }
-            return "⚙️ Backend & Core"; // Default fallback (no "Other" category)
+            return "⚙️  Backend & Core"; // Default fallback (no "Other" category)
         }
 
         // REQUIRED SKILLS - Always installed, not shown in selection
-        const REQUIRED_SKILLS = ["auto-learner"];
+        const REQUIRED_SKILLS = ["skill-generator"];
 
         // Filter out required skills from selection list
         const selectableSkills = skillsInRepo.filter(s => !REQUIRED_SKILLS.includes(s.value));
@@ -337,7 +276,7 @@ export async function run(spec) {
     }
 
     // Check for required skills and show info
-    const CORE_REQUIRED = ["auto-learner"];
+    const CORE_REQUIRED = ["skill-generator"];
     const installedRequired = selectedSkills.filter(s => CORE_REQUIRED.includes(s));
 
     stepLine();
@@ -566,39 +505,22 @@ export async function run(spec) {
         archInstalled = true;
     }
 
-    // Install knowledge/ folder if it exists (required for Agent CLI)
+    // Install knowledge if it exists (required for Agent CLI)
     const knowledgeDir = path.join(baseAgentDir, "knowledge");
-    const targetKnowledgeDir = path.join(WORKSPACE, "..", "knowledge"); // FIXED: was WORKSPACE/knowledge, now WORKSPACE/../knowledge
+    const targetKnowledgeDir = path.join(WORKSPACE, "..", "knowledge");
     let knowledgeInstalled = false;
 
-    console.log(`[Install] === KNOWLEDGE DEBUG ===`);
-    console.log(`[Install] baseAgentDir: ${baseAgentDir}`);
-    console.log(`[Install] baseAgentDir exists: ${fs.existsSync(baseAgentDir)}`);
-    if (fs.existsSync(baseAgentDir)) {
-        console.log(`[Install] baseAgentDir contents: ${fs.readdirSync(baseAgentDir).join(', ')}`);
-    }
-    console.log(`[Install] knowledgeDir: ${knowledgeDir}`);
-    console.log(`[Install] knowledgeDir exists: ${fs.existsSync(knowledgeDir)}`);
-    console.log(`[Install] targetKnowledgeDir: ${targetKnowledgeDir}`);
-
     if (fs.existsSync(knowledgeDir) && !fs.existsSync(targetKnowledgeDir)) {
-        // Copy entire knowledge folder recursively (like config/)
         fs.cpSync(knowledgeDir, targetKnowledgeDir, { recursive: true });
-        step("Installed knowledge/ (lessons, patterns)");
+        step("Installed knowledge/");
         knowledgeInstalled = true;
     } else if (!fs.existsSync(targetKnowledgeDir)) {
-        // Create minimal knowledge folder with empty knowledge.yaml
+        // Create empty knowledge folder for Agent CLI
         fs.mkdirSync(targetKnowledgeDir, { recursive: true });
-        const defaultKnowledge = `version: 6
-createdAt: "${new Date().toISOString()}"
-updatedAt: "${new Date().toISOString()}"
-lessons: []
-`;
-        fs.writeFileSync(path.join(targetKnowledgeDir, "knowledge.yaml"), defaultKnowledge);
+        // Create minimal structure for Agent CLI
+        fs.writeFileSync(path.join(targetKnowledgeDir, "lessons-learned.yaml"), "# Lessons learned by AI Agent\nlessons: []\n");
         step("Created knowledge/ (Agent CLI ready)");
         knowledgeInstalled = true;
-    } else {
-        console.log(`[Install] knowledge/ already exists, skipping`);
     }
 
     // Install config/ if it exists (required for skill configuration)
@@ -693,6 +615,80 @@ lessons: []
         ss.stop("Installed .shared/ (ui-ux-pro-max data)");
     }
 
+    // Install VS Code Extension (PikaKit Skill Generator) if available
+    const vsixDir = path.join(tmp, "packages", "pikakit-vscode");
+    let extensionInstalled = false;
+
+    if (fs.existsSync(vsixDir)) {
+        stepLine();
+        const es = spinner();
+        es.start("Installing VS Code Extension");
+
+        try {
+            // Check if VSIX already built
+            let vsixPath = null;
+            const files = fs.readdirSync(vsixDir);
+            const vsixFile = files.find(f => f.endsWith(".vsix"));
+
+            if (vsixFile) {
+                vsixPath = path.join(vsixDir, vsixFile);
+            } else {
+                // Build VSIX if needed
+                es.message("Building extension...");
+                await execAsync("npm install", { cwd: vsixDir, timeout: 60000 });
+                await execAsync("npm run compile", { cwd: vsixDir, timeout: 30000 });
+                await execAsync("npx vsce package --allow-missing-repository -o pikakit.vsix", { cwd: vsixDir, timeout: 30000 });
+                vsixPath = path.join(vsixDir, "pikakit.vsix");
+            }
+
+            if (vsixPath && fs.existsSync(vsixPath)) {
+                let installedTo = [];
+
+                // Install to VS Code
+                try {
+                    await execAsync(`code --install-extension "${vsixPath}"`, { timeout: 30000 });
+                    installedTo.push("VS Code");
+                } catch {
+                    // VS Code not available, continue
+                }
+
+                // Also install to Antigravity extensions folder
+                const antigravityExt = path.join(os.homedir(), ".antigravity", "extensions");
+                if (fs.existsSync(path.join(os.homedir(), ".antigravity"))) {
+                    try {
+                        fs.mkdirSync(antigravityExt, { recursive: true });
+                        const extDest = path.join(antigravityExt, "pikakit.pikakit-skill-generator-1.0.0");
+
+                        // Copy extension source files (not VSIX, but actual extension)
+                        const outDir = path.join(vsixDir, "out");
+                        if (fs.existsSync(outDir)) {
+                            fs.mkdirSync(extDest, { recursive: true });
+                            // Copy required files
+                            fs.cpSync(path.join(vsixDir, "package.json"), path.join(extDest, "package.json"));
+                            fs.cpSync(outDir, path.join(extDest, "out"), { recursive: true });
+                            if (fs.existsSync(path.join(vsixDir, "README.md"))) {
+                                fs.cpSync(path.join(vsixDir, "README.md"), path.join(extDest, "README.md"));
+                            }
+                            installedTo.push("Antigravity");
+                        }
+                    } catch {
+                        // Antigravity install failed, continue
+                    }
+                }
+
+                if (installedTo.length > 0) {
+                    extensionInstalled = true;
+                    es.stop(`Installed PikaKit VS Code Extension (${installedTo.join(", ")})`);
+                } else {
+                    es.stop(c.yellow("VS Code extension not installed (no IDE detected)"));
+                }
+            }
+        } catch (err) {
+            es.stop(c.yellow("VS Code extension skipped"));
+            step(c.dim("Install manually: code --install-extension pikakit.vsix"));
+        }
+    }
+
     // Installation complete step
     stepLine();
     step("Installation complete");
@@ -744,6 +740,11 @@ lessons: []
         successContent += `${c.cyan("✓")} ${c.dim(".agent/.shared/ (ui-ux-pro-max data)")}\n`;
     }
 
+    // VS Code Extension summary
+    if (extensionInstalled) {
+        successContent += `${c.cyan("✓")} ${c.dim("PikaKit VS Code Extension")}\n`;
+    }
+
     // Build title
     const parts = [`${selectedSkills.length} skills`];
     if (workflowsInstalled > 0) parts.push(`${workflowsInstalled} workflows`);
@@ -758,62 +759,25 @@ lessons: []
         titleAlignment: "left"
     }).split("\n").map(l => `${c.gray(S.branch)}  ${l}`).join("\n"));
 
-    // === SINGLE-SOURCE ARCHITECTURE ===
-    // Copy lib/agent-cli from cloned repo BEFORE deleting tmp
-    // This ensures AutoLearn CLI comes from agent-skill-kit repo, not npm
-    const agentCliSrc = path.join(tmp, "lib", "agent-cli");
-    const agentCliLocalCache = path.join(os.tmpdir(), "pikakit-agent-cli-cache");
-    let agentCliAvailable = false;
-
-    if (fs.existsSync(agentCliSrc)) {
-        // Cache lib/agent-cli to temp location before tmp is deleted
-        if (fs.existsSync(agentCliLocalCache)) {
-            fs.rmSync(agentCliLocalCache, { recursive: true, force: true });
-        }
-        fs.cpSync(agentCliSrc, agentCliLocalCache, { recursive: true });
-        agentCliAvailable = true;
-        console.log(`[Install] Cached lib/agent-cli from repo (${fs.readdirSync(agentCliSrc).length} items)`);
-    }
-
     fs.rmSync(tmp, { recursive: true, force: true });
 
-    // Ask user about AutoLearn installation
-    stepLine();
-    const installAutoLearn = await confirm({
-        message: "Install AutoLearn (enables 'agent' command for learning & self-improvement)?",
-        initialValue: true
-    });
-
-    if (isCancel(installAutoLearn)) {
-        cancel("Installation cancelled");
-        process.exit(0);
-    }
-
     // Install CLI package
     stepLine();
     const cliSpinner = spinner();
-    const cliPackage = "pikakit";
+    const cliPackage = "add-skill-kit";
 
     if (isGlobal) {
-        if (installAutoLearn) {
-            cliSpinner.start(`Installing CLI globally (${cliPackage})`);
-        } else {
-            cliSpinner.start(`Installing kit CLI globally (${cliPackage})`);
-        }
+        cliSpinner.start(`Installing kit CLI globally (${cliPackage})`);
         try {
             await execAsync(`npm install -g ${cliPackage}`, { timeout: 120000 });
             cliSpinner.stop("CLI installed globally");
-            if (installAutoLearn) {
-                step(c.dim("Commands: agent, kit"));
-            } else {
-                step(c.dim("Command: kit"));
-            }
+            step(c.dim("Command: kit"));
         } catch (e) {
             cliSpinner.stop(c.yellow("Global CLI installation failed"));
             step(c.dim(`Try running manually: npm i -g ${cliPackage}`));
         }
     } else {
-        cliSpinner.start(`Installing Agent CLI locally (${cliPackage})`);
+        cliSpinner.start(`Installing kit CLI locally (${cliPackage})`);
         try {
             await execAsync(`npm install -D ${cliPackage}`, { timeout: 120000 });
             cliSpinner.stop("CLI installed locally");
@@ -825,67 +789,29 @@ lessons: []
                     const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
                     pkg.scripts = pkg.scripts || {};
 
-                    // Always add kit script
                     if (!pkg.scripts.kit) {
                         pkg.scripts.kit = "kit";
                     }
 
-                    // Add agent script only if AutoLearn enabled
-                    if (installAutoLearn && !pkg.scripts.agent) {
-                        pkg.scripts.agent = "agent";
-                    }
-
                     fs.writeFileSync(pkgPath, JSON.stringify(pkg, null, 2) + "\n");
-                    if (installAutoLearn) {
-                        step(c.green("✓ Added npm scripts: 'agent', 'kit'"));
-                    } else {
-                        step(c.green("✓ Added npm script: 'kit'"));
-                    }
+                    step(c.green("✓ Added npm script: 'kit'"));
                 }
             } catch (scriptErr) {
-                step(c.yellow("âš  Could not add npm scripts automatically"));
+                step(c.yellow("⚠ Could not add npm scripts automatically"));
             }
 
             // Create wrapper scripts for direct command access (Windows + Unix)
             try {
                 const projectRoot = process.cwd();
-                const binDir = path.join(projectRoot, "node_modules", ".bin");
 
-                // Always create kit wrappers at project root
-                const kitCmd = `@echo off\nnode "%~dp0node_modules\\pikakit\\bin\\kit.js" %*`;
-                const kitSh = `#!/bin/sh\nnode "$(dirname "$0")/node_modules/pikakit/bin/kit.js" "$@"`;
+                // Always create kit wrappers
+                const kitCmd = `@echo off\nnode "%~dp0node_modules\\add-skill-kit\\bin\\kit.js" %*`;
+                const kitSh = `#!/bin/sh\nnode "$(dirname "$0")/node_modules/add-skill-kit/bin/kit.js" "$@"`;
                 fs.writeFileSync(path.join(projectRoot, "kit.cmd"), kitCmd);
                 fs.writeFileSync(path.join(projectRoot, "kit"), kitSh, { mode: 0o755 });
 
-                // Also create in node_modules/.bin for npx support
-                if (fs.existsSync(binDir)) {
-                    const kitBinCmd = `@echo off\nnode "%~dp0..\\pikakit\\bin\\kit.js" %*`;
-                    const kitBinSh = `#!/bin/sh\nnode "$(dirname "$0")/../pikakit/bin/kit.js" "$@"`;
-                    fs.writeFileSync(path.join(binDir, "kit.cmd"), kitBinCmd);
-                    fs.writeFileSync(path.join(binDir, "kit"), kitBinSh, { mode: 0o755 });
-                }
-
-                if (installAutoLearn) {
-                    // Create agent wrappers only if AutoLearn enabled
-                    const agentCmd = `@echo off\nnode "%~dp0node_modules\\pikakit\\lib\\agent-cli\\bin\\agent.js" %*`;
-                    const agentSh = `#!/bin/sh\nnode "$(dirname "$0")/node_modules/pikakit/lib/agent-cli/bin/agent.js" "$@"`;
-                    fs.writeFileSync(path.join(projectRoot, "agent.cmd"), agentCmd);
-                    fs.writeFileSync(path.join(projectRoot, "agent"), agentSh, { mode: 0o755 });
-
-                    // Also create in node_modules/.bin for npx support
-                    if (fs.existsSync(binDir)) {
-                        const agentBinCmd = `@echo off\nnode "%~dp0..\\pikakit\\lib\\agent-cli\\bin\\agent.js" %*`;
-                        const agentBinSh = `#!/bin/sh\nnode "$(dirname "$0")/../pikakit/lib/agent-cli/bin/agent.js" "$@"`;
-                        fs.writeFileSync(path.join(binDir, "agent.cmd"), agentBinCmd);
-                        fs.writeFileSync(path.join(binDir, "agent"), agentBinSh, { mode: 0o755 });
-                    }
-
-                    step(c.green("✔ Created wrapper scripts: agent, kit"));
-                    step(c.dim("Run: npx agent | npx kit | .\\agent | .\\kit (Windows)"));
-                } else {
-                    step(c.green("✔ Created wrapper script: kit"));
-                    step(c.dim("Run: npx kit | .\\kit (Windows)"));
-                }
+                step(c.green(" Created wrapper script: kit"));
+                step(c.dim("Run directly: ./kit (Unix) | kit (Windows)"));
             } catch (wrapperErr) {
                 step(c.dim("Run: npx kit"));
             }
@@ -895,35 +821,6 @@ lessons: []
         }
     }
 
-    // === SINGLE-SOURCE: Overwrite lib/agent-cli with version from repo ===
-    if (agentCliAvailable && !isGlobal) {
-        stepLine();
-        const overwriteSpinner = spinner();
-        overwriteSpinner.start("Syncing AutoLearn CLI from repo...");
-        try {
-            const destAgentCli = path.join(process.cwd(), "node_modules", "pikakit", "lib", "agent-cli");
-
-            // Remove existing lib/agent-cli if exists
-            if (fs.existsSync(destAgentCli)) {
-                fs.rmSync(destAgentCli, { recursive: true, force: true });
-            }
-
-            // Copy from cached repo version
-            fs.mkdirSync(path.dirname(destAgentCli), { recursive: true });
-            fs.cpSync(agentCliLocalCache, destAgentCli, { recursive: true });
-
-            // Cleanup cache
-            fs.rmSync(agentCliLocalCache, { recursive: true, force: true });
-
-            const itemCount = fs.readdirSync(destAgentCli).length;
-            overwriteSpinner.stop(`AutoLearn CLI synced from repo (${itemCount} modules)`);
-            step(c.green("✓ Single-source: lib/agent-cli from agent-skill-kit"));
-        } catch (syncErr) {
-            overwriteSpinner.stop(c.yellow("AutoLearn sync skipped (using npm version)"));
-            console.log(`[Install] Sync error: ${syncErr.message}`);
-        }
-    }
-
     // Run npm install to ensure all skill dependencies are available
     stepLine();
     const depsSpinner = spinner();
@@ -938,26 +835,6 @@ lessons: []
 
     // Python dependencies no longer needed - all scripts migrated to JS
 
-    // Final Quick Start Guide
-    stepLine();
-    console.log(boxen(
-        (installAutoLearn ?
-            `${c.cyan("🤖 AutoLearn Agent:")}\n` +
-            `${c.white("npx agent")}  ${c.dim("or")}  ${c.white("npm run agent")}  ${c.dim("or")}  ${c.white(".\\\\agent")}\n` +
-            `${c.dim("→ Learning, self-improvement, pattern detection")}\n\n` : "") +
-        `${c.cyan("🔧 Kit Commands:")}\n` +
-        `${c.white("npx kit")}    ${c.dim("or")}  ${c.white("npm run kit")}    ${c.dim("or")}  ${c.white(".\\\\kit")}\n` +
-        `${c.dim("→ Skill management, diagnostics, updates")}\n\n` +
-        `${c.yellow("Note:")} Windows PowerShell requires ${c.white(".\\\\")} prefix.`,
-        {
-            padding: 1,
-            borderColor: "cyan",
-            borderStyle: "round",
-            title: c.cyan("⚡ Get Started"),
-            titleAlignment: "left"
-        }
-    ).split("\n").map(l => `${c.gray(S.branch)}  ${l}`).join("\n"));
-
     stepLine();
     console.log(` ${c.cyan("Done!")}`);
     console.log();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikakit",
-  "version": "3.0.5",
+  "version": "3.7.2",
   "description": "Enterprise-grade Agent Skill Manager with Antigravity Skills support, Progressive Disclosure detection, and semantic routing validation",
   "license": "MIT",
   "author": "pikakit <pikakit@gmail.com>",
@@ -15,8 +15,7 @@
   "type": "module",
   "bin": {
     "pikakit": "bin/cli.mjs",
-    "kit": "bin/kit.js",
-    "agent": "lib/agent-cli/bin/agent.js"
+    "kit": "bin/kit.js"
   },
   "files": [
     "bin/",
@@ -74,4 +73,4 @@
     "prettier": "^3.2.5",
     "vitest": "^4.0.18"
   }
-}
+}