pikakit 1.0.25 → 1.0.27

package/bin/lib/commands/install.js

@@ -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 } from "../config.js";
+import { WORKSPACE, GLOBAL_DIR, OFFLINE, GLOBAL, REPO_CACHE_DIR, CACHE_TTL_MS, FORCE_REFRESH } from "../config.js";
 import { installSkill } from "../installer.js";
 
 /**
@@ -47,31 +47,92 @@ export async function run(spec) {
     step("Source: " + c.cyan(url));
 
     const s = spinner();
-    s.start("Cloning repository");
-
     const tmp = fs.mkdtempSync(path.join(os.tmpdir(), "add-skill-"));
 
-    // Retry logic with exponential backoff
-    const MAX_RETRIES = 3;
+    // --- 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;
+
+    // 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("Checking cache...");
+            }
+        } catch {
+            // Invalid cache, will refresh
+        }
+    }
+
     let lastError = null;
+    const MAX_RETRIES = 3;
 
-    for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
+    if (useCache) {
+        // Fast path: Update cache with git fetch (much faster than clone)
         try {
-            await execAsync(`git clone --depth=1 ${url} "${tmp}"`, { timeout: 60000 });
-            if (ref) await execAsync(`git -C "${tmp}" checkout ${ref}`, { timeout: 30000 });
-            lastError = null;
-            break;
+            s.message("Updating from cache...");
+            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("Repository cloned");
         } catch (err) {
-            lastError = err;
+            // Cache update failed, fall back to fresh clone
+            s.message("Cache outdated, cloning fresh...");
+            useCache = false;
+            cacheHit = false;
+        }
+    }
 
-            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));
+    if (!useCache) {
+        // Fresh clone with retry logic
+        s.start(FORCE_REFRESH ? "Force refreshing repository..." : "Cloning repository");
 
-                // Clean up failed attempt
-                try { fs.rmSync(tmp, { recursive: true, force: true }); } catch { }
-                fs.mkdirSync(tmp, { recursive: true });
+        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 });
+                }
             }
         }
     }
@@ -99,7 +160,9 @@ export async function run(spec) {
         return;
     }
 
-    s.stop("Repository cloned");
+    if (!cacheHit) {
+        s.stop("Repository cloned");
+    }
 
     // Find skills in repo - check multiple possible locations
     const skillsInRepo = [];
@@ -399,12 +462,13 @@ export async function run(spec) {
 
     const installResults = { success: [], failed: [] };
 
-    for (const sn of selectedSkills) {
-        const src = skillPathMap[sn] || path.join(skillsDir || tmp, sn);
-
-        const is = spinner();
-        is.start(`Installing ${sn} to ${selectedAgents.length} agents`);
+    // --- Parallel Skill Installation (Batch processing) ---
+    const CONCURRENCY_LIMIT = 5; // Process 5 skills at a time
+    const totalSkills = selectedSkills.length;
 
+    // Create installation function
+    async function installSingleSkill(sn) {
+        const src = skillPathMap[sn] || path.join(skillsDir || tmp, sn);
         const result = await installSkillForAgents(src, sn, selectedAgents, {
             method: installMethod,
             scope: isGlobal ? "global" : "project",
@@ -413,17 +477,30 @@ export async function run(spec) {
                 ref: ref || null
             }
         });
+        return { skill: sn, ...result };
+    }
 
-        installResults.success.push(...result.success);
-        installResults.failed.push(...result.failed);
+    // Progress spinner for batch installation
+    const batchSpinner = spinner();
+    batchSpinner.start(`Installing ${totalSkills} skills to ${selectedAgents.length} agents (parallel)...`);
 
-        if (result.failed.length === 0) {
-            is.stop(`Installed ${sn} (${result.success.length} agents)`);
-        } else {
-            is.stop(`${sn}: ${result.success.length} success, ${result.failed.length} failed`);
+    // Process in batches
+    let completed = 0;
+    for (let i = 0; i < selectedSkills.length; i += CONCURRENCY_LIMIT) {
+        const batch = selectedSkills.slice(i, i + CONCURRENCY_LIMIT);
+        const batchResults = await Promise.all(batch.map(installSingleSkill));
+
+        for (const r of batchResults) {
+            installResults.success.push(...r.success);
+            installResults.failed.push(...r.failed);
+            completed++;
         }
+
+        batchSpinner.message(`Installing skills... ${completed}/${totalSkills}`);
     }
 
+    batchSpinner.stop(`Installed ${completed} skills (${installResults.success.length} agents, ${installResults.failed.length} failed)`);
+
 
     // Derive base .agent directory from skillsDir
     // If skillsDir is .../skills, then baseAgentDir is parent (.agent)

package/bin/lib/config.js

@@ -26,6 +26,12 @@ export const REGISTRIES_FILE = path.join(CACHE_ROOT, "registries.json");
 /** Backup directory */
 export const BACKUP_DIR = path.join(CACHE_ROOT, "backups");
 
+/** Repository cache directory for git clone caching */
+export const REPO_CACHE_DIR = path.join(CACHE_ROOT, "repos");
+
+/** Cache TTL in milliseconds (24 hours) */
+export const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+
 // --- Argument Parsing ---
 
 const args = process.argv.slice(2);
@@ -68,6 +74,9 @@ export const LOCKED = flags.has("--locked");
 /** @type {boolean} Offline mode (skip network operations) */
 export const OFFLINE = flags.has("--offline");
 
+/** @type {boolean} Force refresh cache (re-clone from remote) */
+export const FORCE_REFRESH = flags.has("--force-refresh") || flags.has("--no-cache");
+
 // --- Package Info ---
 
 import { createRequire } from "module";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pikakit",
-  "version": "1.0.25",
+  "version": "1.0.27",
   "description": "Enterprise-grade Agent Skill Manager with Antigravity Skills support, Progressive Disclosure detection, and semantic routing validation",
   "license": "MIT",
   "author": "pikakit <pikakit@gmail.com>",