pikakit 3.9.103 → 3.9.104

package/README.md

@@ -4,7 +4,7 @@
 
 ### Transform your AI Agent into a FAANG-level engineering team
 
-[![npm version](https://img.shields.io/badge/npm-v3.9.103-7c3aed?style=for-the-badge&logo=npm&logoColor=white&labelColor=18181b)](https://www.npmjs.com/package/pikakit)
+[![npm version](https://img.shields.io/badge/npm-v3.9.104-7c3aed?style=for-the-badge&logo=npm&logoColor=white&labelColor=18181b)](https://www.npmjs.com/package/pikakit)
 [![Skills](https://img.shields.io/badge/skills-51-06b6d4?style=for-the-badge&labelColor=18181b)](https://github.com/pikakit/agent-skills)
 [![Agents](https://img.shields.io/badge/agents-21-f59e0b?style=for-the-badge&labelColor=18181b)](https://github.com/pikakit/agent-skills)
 [![Workflows](https://img.shields.io/badge/workflows-18-10b981?style=for-the-badge&labelColor=18181b)](https://github.com/pikakit/agent-skills)
@@ -396,7 +396,7 @@ UNLICENSED — See [LICENSE](LICENSE) for details.
 
 <div align="center">
 
-**⚡ PikaKit v3.9.103**
+**⚡ PikaKit v3.9.104**
 
 *Composable Skills · Coordinated Agents · Intelligent Execution*
 

package/bin/lib/commands/install.js

@@ -26,6 +26,19 @@ const pkg = require('../../../package.json');
  * @param {string} spec - Skill spec (org/repo or org/repo#skill)
  */
 export async function run(spec) {
+    // Global timeout safety net (5 minutes)
+    const GLOBAL_TIMEOUT_MS = 5 * 60 * 1000;
+    const globalTimer = setTimeout(() => {
+        console.error(c.red("\n⏱ Installation timed out after 5 minutes."));
+        console.error(c.dim("This usually means a network issue or a hung process."));
+        console.error(c.dim("Try again with: npx pikakit --force"));
+        process.exit(1);
+    }, GLOBAL_TIMEOUT_MS);
+    globalTimer.unref(); // Don't keep process alive just for this timer
+
+    // Non-interactive mode: auto-accept defaults when stdin is not a TTY
+    const isInteractive = process.stdin.isTTY !== false;
+
     if (!spec) {
         fatal("Missing skill spec. Usage: add-skill <org/repo>");
         return;
@@ -62,8 +75,15 @@ export async function run(spec) {
 
     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 });
+            await execAsync(`git clone --depth=1 ${url} "${tmp}"`, {
+                timeout: 60000,
+                maxBuffer: 10 * 1024 * 1024,
+                env: { ...process.env, GIT_TERMINAL_PROMPT: "0" }
+            });
+            if (ref) await execAsync(`git -C "${tmp}" checkout ${ref}`, {
+                timeout: 30000,
+                maxBuffer: 10 * 1024 * 1024
+            });
             lastError = null;
             break;
         } catch (err) {
@@ -257,21 +277,28 @@ export async function run(spec) {
             return a.localeCompare(b);
         });
 
-        // Show categories in multiselect
-        const selectedCategories = await multiselect({
-            message: `Found ${skillsInRepo.length} skills — ${c.gray("[")}${c.cyan("Space")}${c.gray("]")}select ${c.gray("[")}${c.cyan("Enter")}${c.gray("]")}continue`,
-            options: sortedCategories.map(cat => ({
-                label: `${cat} (${grouped[cat].length} skills)`,
-                value: cat
-            })),
-            initialValues: sortedCategories, // Pre-select all
-            required: true
-        });
+        // Non-interactive: auto-select all categories
+        let selectedCategories;
+        if (!isInteractive || FORCE) {
+            selectedCategories = sortedCategories;
+            step(c.dim(`Auto-selected all ${sortedCategories.length} categories (non-interactive mode)`));
+        } else {
+            // Show categories in multiselect
+            selectedCategories = await multiselect({
+                message: `Found ${skillsInRepo.length} skills — ${c.gray("[")}${c.cyan("Space")}${c.gray("]")}select ${c.gray("[")}${c.cyan("Enter")}${c.gray("]")}continue`,
+                options: sortedCategories.map(cat => ({
+                    label: `${cat} (${grouped[cat].length} skills)`,
+                    value: cat
+                })),
+                initialValues: sortedCategories, // Pre-select all
+                required: true
+            });
 
-        if (isCancel(selectedCategories)) {
-            cancel("Cancelled.");
-            fs.rmSync(tmp, { recursive: true, force: true });
-            return;
+            if (isCancel(selectedCategories)) {
+                cancel("Cancelled.");
+                fs.rmSync(tmp, { recursive: true, force: true });
+                return;
+            }
         }
 
         // Clear multiselect default summary line (inline categories wrap)
@@ -329,9 +356,10 @@ export async function run(spec) {
             { name: "Antigravity", cli: "antigravity" }
         ];
 
-        for (const ide of vsCodeBasedIDEs) {
+        // Detect IDEs in parallel (not sequentially) to avoid cumulative timeout
+        await Promise.allSettled(vsCodeBasedIDEs.map(async (ide) => {
             try {
-                await execAsync(`${ide.cli} --version`, { timeout: 5000 });
+                await execAsync(`${ide.cli} --version`, { timeout: 3000 });
                 detectedIDEs.push(ide);
             } catch {
                 // Fallback: check known installation paths
@@ -343,16 +371,20 @@ export async function run(spec) {
                     detectedIDEs.push(ide);
                 }
             }
-        }
+        }));
 
         if (detectedIDEs.length > 0) {
-            const installExt = await confirm({
-                message: `Install PikaKit Engine extension? ${c.dim(`(${detectedIDEs.map(i => i.name).join(", ")})`)}`,
-                initialValue: true
-            });
-
-            if (!isCancel(installExt) && installExt) {
+            if (!isInteractive || FORCE) {
                 wantExtension = true;
+            } else {
+                const installExt = await confirm({
+                    message: `Install PikaKit Engine extension? ${c.dim(`(${detectedIDEs.map(i => i.name).join(", ")})`)}`,
+                    initialValue: true
+                });
+
+                if (!isCancel(installExt) && installExt) {
+                    wantExtension = true;
+                }
             }
         }
     }
@@ -376,7 +408,13 @@ export async function run(spec) {
     // --- Select agents (Vercel-style) ---
     const { selectAgentsPrompt, selectScopePrompt, selectMethodPrompt } = await import("../ui.js");
 
-    const selectedAgents = await selectAgentsPrompt(detectedAgents);
+    let selectedAgents;
+    if (!isInteractive || FORCE) {
+        selectedAgents = detectedAgents;
+        step(c.dim(`Auto-selected ${detectedAgents.length} agents (non-interactive mode)`));
+    } else {
+        selectedAgents = await selectAgentsPrompt(detectedAgents);
+    }
 
     if (!selectedAgents || selectedAgents.length === 0) {
         fs.rmSync(tmp, { recursive: true, force: true });
@@ -387,27 +425,36 @@ export async function run(spec) {
     let isGlobal = GLOBAL;
 
     if (!GLOBAL) {
-        const scope = await selectScopePrompt();
+        if (!isInteractive || FORCE) {
+            isGlobal = false; // Default to project scope
+        } else {
+            const scope = await selectScopePrompt();
 
-        if (!scope) {
-            fs.rmSync(tmp, { recursive: true, force: true });
-            return;
-        }
+            if (!scope) {
+                fs.rmSync(tmp, { recursive: true, force: true });
+                return;
+            }
 
-        isGlobal = scope === "global";
+            isGlobal = scope === "global";
+        }
     }
 
     // --- Select installation method ---
-    const installMethod = await selectMethodPrompt();
+    let installMethod;
+    if (!isInteractive || FORCE) {
+        installMethod = "symlink"; // Default to symlink
+    } else {
+        installMethod = await selectMethodPrompt();
 
-    if (!installMethod) {
-        fs.rmSync(tmp, { recursive: true, force: true });
-        return;
+        if (!installMethod) {
+            fs.rmSync(tmp, { recursive: true, force: true });
+            return;
+        }
     }
 
-    // Confirmation (skip if --force)
-    let shouldProceed = FORCE;
-    if (!FORCE) {
+    // Confirmation (skip if --force or non-interactive)
+    let shouldProceed = FORCE || !isInteractive;
+    if (!shouldProceed) {
         shouldProceed = await confirm({ message: "Proceed with installation?", initialValue: true });
 
         if (isCancel(shouldProceed) || !shouldProceed) {
@@ -457,118 +504,120 @@ export async function run(spec) {
     // If skillsDir is .../skills, then baseAgentDir is parent (.agent)
     const baseAgentDir = skillsDir ? path.dirname(skillsDir) : path.join(tmp, ".agent");
 
-    // Install workflows (silent)
-    const workflowsDir = path.join(baseAgentDir, "workflows");
-    const targetWorkflowsDir = path.join(WORKSPACE, "..", "workflows");
+    // --- Post-install file copy phase (wrapped in try/catch for robustness) ---
     let workflowsInstalled = 0;
-
-    if (fs.existsSync(workflowsDir)) {
-        fs.mkdirSync(targetWorkflowsDir, { recursive: true });
-        const workflows = fs.readdirSync(workflowsDir).filter(f => f.endsWith(".md"));
-        for (const wf of workflows) {
-            const src = path.join(workflowsDir, wf);
-            const dest = path.join(targetWorkflowsDir, wf);
-            if (!fs.existsSync(dest)) {
-                fs.copyFileSync(src, dest);
-                workflowsInstalled++;
-            }
-        }
-    }
-
-    // Install GEMINI.md (silent)
-    const geminiSrc = path.join(baseAgentDir, "GEMINI.md");
-    const geminiDest = path.join(WORKSPACE, "..", "GEMINI.md");
     let geminiInstalled = false;
-    if (fs.existsSync(geminiSrc) && !fs.existsSync(geminiDest)) {
-        fs.copyFileSync(geminiSrc, geminiDest);
-        geminiInstalled = true;
-    }
+    let agentsInstalled = 0;
+    let archInstalled = false;
+    let configInstalled = false;
+    let metricsInstalled = false;
+    let policyDocsInstalled = 0;
+    let rulesInstalled = 0;
+    let sharedInstalled = false;
 
-    // Install agents (silent)
-    const agentsDir = path.join(baseAgentDir, "agents");
+    const targetWorkflowsDir = path.join(WORKSPACE, "..", "workflows");
+    const geminiDest = path.join(WORKSPACE, "..", "GEMINI.md");
     const targetAgentsDir = path.join(WORKSPACE, "..", "agents");
-    let agentsInstalled = 0;
+    const archDest = path.join(WORKSPACE, "..", "ARCHITECTURE.md");
 
-    if (fs.existsSync(agentsDir)) {
-        fs.mkdirSync(targetAgentsDir, { recursive: true });
-        const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith(".md"));
-        for (const agent of agents) {
-            const src = path.join(agentsDir, agent);
-            const dest = path.join(targetAgentsDir, agent);
-            if (!fs.existsSync(dest)) {
-                fs.copyFileSync(src, dest);
-                agentsInstalled++;
+    try {
+        // Install workflows (silent)
+        const workflowsDir = path.join(baseAgentDir, "workflows");
+        if (fs.existsSync(workflowsDir)) {
+            fs.mkdirSync(targetWorkflowsDir, { recursive: true });
+            const workflows = fs.readdirSync(workflowsDir).filter(f => f.endsWith(".md"));
+            for (const wf of workflows) {
+                const src = path.join(workflowsDir, wf);
+                const dest = path.join(targetWorkflowsDir, wf);
+                if (!fs.existsSync(dest)) {
+                    fs.copyFileSync(src, dest);
+                    workflowsInstalled++;
+                }
             }
         }
-    }
-
-    // Install ARCHITECTURE.md (silent)
-    const archSrc = path.join(baseAgentDir, "ARCHITECTURE.md");
-    const archDest = path.join(WORKSPACE, "..", "ARCHITECTURE.md");
-    let archInstalled = false;
-    if (fs.existsSync(archSrc) && !fs.existsSync(archDest)) {
-        fs.copyFileSync(archSrc, archDest);
-        archInstalled = true;
-    }
-
 
+        // Install GEMINI.md (silent)
+        const geminiSrc = path.join(baseAgentDir, "GEMINI.md");
+        if (fs.existsSync(geminiSrc) && !fs.existsSync(geminiDest)) {
+            fs.copyFileSync(geminiSrc, geminiDest);
+            geminiInstalled = true;
+        }
 
-    // Install config (silent)
-    const configDir = path.join(baseAgentDir, "config");
-    const targetConfigDir = path.join(WORKSPACE, "..", "config");
-    let configInstalled = false;
-    if (fs.existsSync(configDir) && !fs.existsSync(targetConfigDir)) {
-        fs.cpSync(configDir, targetConfigDir, { recursive: true });
-        configInstalled = true;
-    }
+        // Install agents (silent)
+        const agentsDir = path.join(baseAgentDir, "agents");
+        if (fs.existsSync(agentsDir)) {
+            fs.mkdirSync(targetAgentsDir, { recursive: true });
+            const agents = fs.readdirSync(agentsDir).filter(f => f.endsWith(".md"));
+            for (const agent of agents) {
+                const src = path.join(agentsDir, agent);
+                const dest = path.join(targetAgentsDir, agent);
+                if (!fs.existsSync(dest)) {
+                    fs.copyFileSync(src, dest);
+                    agentsInstalled++;
+                }
+            }
+        }
 
+        // Install ARCHITECTURE.md (silent)
+        const archSrc = path.join(baseAgentDir, "ARCHITECTURE.md");
+        if (fs.existsSync(archSrc) && !fs.existsSync(archDest)) {
+            fs.copyFileSync(archSrc, archDest);
+            archInstalled = true;
+        }
 
+        // Install config (silent)
+        const configDir = path.join(baseAgentDir, "config");
+        const targetConfigDir = path.join(WORKSPACE, "..", "config");
+        if (fs.existsSync(configDir) && !fs.existsSync(targetConfigDir)) {
+            fs.cpSync(configDir, targetConfigDir, { recursive: true });
+            configInstalled = true;
+        }
 
-    // Install metrics (silent)
-    const metricsDir = path.join(baseAgentDir, "metrics");
-    const targetMetricsDir = path.join(WORKSPACE, "..", "metrics");
-    let metricsInstalled = false;
-    if (fs.existsSync(metricsDir) && !fs.existsSync(targetMetricsDir)) {
-        fs.cpSync(metricsDir, targetMetricsDir, { recursive: true });
-        metricsInstalled = true;
-    }
+        // Install metrics (silent)
+        const metricsDir = path.join(baseAgentDir, "metrics");
+        const targetMetricsDir = path.join(WORKSPACE, "..", "metrics");
+        if (fs.existsSync(metricsDir) && !fs.existsSync(targetMetricsDir)) {
+            fs.cpSync(metricsDir, targetMetricsDir, { recursive: true });
+            metricsInstalled = true;
+        }
 
-    // Install policy documents (silent)
-    const policyDocs = ["CONTINUOUS_EXECUTION_POLICY.md", "WORKFLOW_CHAINS.md"];
-    let policyDocsInstalled = 0;
-    for (const doc of policyDocs) {
-        const docSrc = path.join(baseAgentDir, doc);
-        const docDest = path.join(WORKSPACE, "..", doc);
-        if (fs.existsSync(docSrc) && !fs.existsSync(docDest)) {
-            fs.copyFileSync(docSrc, docDest);
-            policyDocsInstalled++;
+        // Install policy documents (silent)
+        const policyDocs = ["CONTINUOUS_EXECUTION_POLICY.md", "WORKFLOW_CHAINS.md"];
+        for (const doc of policyDocs) {
+            const docSrc = path.join(baseAgentDir, doc);
+            const docDest = path.join(WORKSPACE, "..", doc);
+            if (fs.existsSync(docSrc) && !fs.existsSync(docDest)) {
+                fs.copyFileSync(docSrc, docDest);
+                policyDocsInstalled++;
+            }
         }
-    }
 
-    // Install rules (silent)
-    const rulesDir = path.join(baseAgentDir, "rules");
-    const targetRulesDir = path.join(WORKSPACE, "..", "rules");
-    let rulesInstalled = 0;
-    if (fs.existsSync(rulesDir)) {
-        fs.mkdirSync(targetRulesDir, { recursive: true });
-        const rules = fs.readdirSync(rulesDir).filter(f => f.endsWith(".md"));
-        for (const rule of rules) {
-            const src = path.join(rulesDir, rule);
-            const dest = path.join(targetRulesDir, rule);
-            if (!fs.existsSync(dest)) {
-                fs.copyFileSync(src, dest);
-                rulesInstalled++;
+        // Install rules (silent)
+        const rulesDir = path.join(baseAgentDir, "rules");
+        const targetRulesDir = path.join(WORKSPACE, "..", "rules");
+        if (fs.existsSync(rulesDir)) {
+            fs.mkdirSync(targetRulesDir, { recursive: true });
+            const rules = fs.readdirSync(rulesDir).filter(f => f.endsWith(".md"));
+            for (const rule of rules) {
+                const src = path.join(rulesDir, rule);
+                const dest = path.join(targetRulesDir, rule);
+                if (!fs.existsSync(dest)) {
+                    fs.copyFileSync(src, dest);
+                    rulesInstalled++;
+                }
             }
         }
-    }
 
-    // Install .shared (silent)
-    const sharedDir = path.join(tmp, ".agent", ".shared");
-    const targetSharedDir = path.join(WORKSPACE, "..", ".shared");
-    let sharedInstalled = false;
-    if (fs.existsSync(sharedDir) && !fs.existsSync(targetSharedDir)) {
-        fs.cpSync(sharedDir, targetSharedDir, { recursive: true });
-        sharedInstalled = true;
+        // Install .shared (silent)
+        const sharedDir = path.join(tmp, ".agent", ".shared");
+        const targetSharedDir = path.join(WORKSPACE, "..", ".shared");
+        if (fs.existsSync(sharedDir) && !fs.existsSync(targetSharedDir)) {
+            fs.cpSync(sharedDir, targetSharedDir, { recursive: true });
+            sharedInstalled = true;
+        }
+    } catch (copyErr) {
+        step(c.yellow(`Warning: Some files failed to copy: ${copyErr.message}`), S.diamond, "yellow");
+        if (process.env.DEBUG) console.error(copyErr.stack);
     }
 
     // Install PikaKit Engine Extension (if user chose yes earlier)
@@ -675,4 +724,7 @@ export async function run(spec) {
         }
     ).split("\n").map(l => `${c.gray(S.branch)}  ${l}`).join("\n"));
     step(`${c.green("✓")} ${c.bold("Installation Complete!")}`);
+
+    // Clear global timeout
+    clearTimeout(globalTimer);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikakit",
-  "version": "3.9.103",
+  "version": "3.9.104",
   "description": "PikaKit — Install 51 skills, 18 workflows, 21 agents into your AI project. One command.",
   "license": "MIT",
   "author": "pikakit <pikakit@gmail.com>",