akm-cli 0.0.16 → 0.0.18

package/dist/config-cli.js

@@ -23,6 +23,8 @@ export function parseConfigValue(key, value) {
             return { embedding: parseEmbeddingConnectionValue(value) };
         case "llm":
             return { llm: parseLlmConnectionValue(value) };
+        case "registries":
+            return { registries: parseRegistriesValue(value) };
         case "output.format":
             return { output: { format: parseOutputFormat(value) } };
         case "output.detail":
@@ -43,6 +45,8 @@ export function getConfigValue(config, key) {
             return config.embedding ?? null;
         case "llm":
             return config.llm ?? null;
+        case "registries":
+            return config.registries ?? DEFAULT_CONFIG.registries ?? [];
         case "output.format":
             return config.output?.format ?? null;
         case "output.detail":
@@ -58,6 +62,7 @@ export function setConfigValue(config, key, rawValue) {
         case "searchPaths":
         case "embedding":
         case "llm":
+        case "registries":
         case "output.format":
         case "output.detail":
             return mergeConfigValue(config, parseConfigValue(key, rawValue));
@@ -73,6 +78,8 @@ export function unsetConfigValue(config, key) {
             return { ...config, embedding: undefined };
         case "llm":
             return { ...config, llm: undefined };
+        case "registries":
+            return { ...config, registries: undefined };
         case "output.format":
             return { ...config, output: mergeOutputConfig(config.output, { format: undefined }) };
         case "output.detail":
@@ -89,6 +96,7 @@ export function listConfig(config) {
         stashDir: config.stashDir ?? null,
         embedding: config.embedding ?? null,
         llm: config.llm ?? null,
+        registries: config.registries ?? DEFAULT_CONFIG.registries ?? [],
     };
 }
 function mergeConfigValue(config, partial) {
@@ -115,6 +123,41 @@ function parseOutputDetail(value) {
         return value;
     throw new UsageError(`Invalid value for output.detail: expected one of brief|normal|full`);
 }
+function parseRegistriesValue(value) {
+    if (value === "null" || value === "")
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new UsageError(`Invalid value for registries: expected JSON array of {url, name?, enabled?, provider?, options?} objects` +
+            ` (e.g. '[{"url":"https://example.com/index.json","name":"my-registry"}]')`);
+    }
+    if (!Array.isArray(parsed)) {
+        throw new UsageError(`Invalid value for registries: expected a JSON array`);
+    }
+    return parsed.map((entry, i) => {
+        if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+            throw new UsageError(`Invalid value for registries[${i}]: expected an object with a "url" field`);
+        }
+        const obj = entry;
+        if (typeof obj.url !== "string" || !obj.url) {
+            throw new UsageError(`Invalid value for registries[${i}]: "url" is required`);
+        }
+        const result = { url: obj.url };
+        if (typeof obj.name === "string" && obj.name)
+            result.name = obj.name;
+        if (typeof obj.enabled === "boolean")
+            result.enabled = obj.enabled;
+        if (typeof obj.provider === "string" && obj.provider)
+            result.provider = obj.provider;
+        if (typeof obj.options === "object" && obj.options !== null && !Array.isArray(obj.options)) {
+            result.options = obj.options;
+        }
+        return result;
+    });
+}
 function parseEmbeddingConnectionValue(value) {
     if (value === "null" || value === "")
         return undefined;

package/dist/config.js

@@ -5,6 +5,7 @@ import { getConfigDir as _getConfigDir, getConfigPath as _getConfigPath } from "
 export const DEFAULT_CONFIG = {
     semanticSearch: true,
     searchPaths: [],
+    registries: [{ url: "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json", name: "official" }],
     output: {
         format: "json",
         detail: "brief",
@@ -113,27 +114,18 @@ function pickKnownKeys(raw) {
     if (Array.isArray(raw.searchPaths)) {
         config.searchPaths = raw.searchPaths.filter((d) => typeof d === "string");
     }
-    // Backward compat: merge legacy mountedStashDirs into searchPaths
-    if (Array.isArray(raw.mountedStashDirs)) {
-        const legacy = raw.mountedStashDirs.filter((d) => typeof d === "string");
-        const existing = new Set(config.searchPaths);
-        for (const d of legacy) {
-            if (!existing.has(d))
-                config.searchPaths.push(d);
-        }
-    }
     const embedding = parseEmbeddingConfig(raw.embedding);
     if (embedding)
         config.embedding = embedding;
     const llm = parseLlmConfig(raw.llm);
     if (llm)
         config.llm = llm;
-    const registry = parseRegistryConfig(raw.registry);
-    if (registry)
-        config.registry = registry;
-    if (Array.isArray(raw.registryUrls)) {
-        config.registryUrls = raw.registryUrls.filter((u) => typeof u === "string" && u.startsWith("http"));
-    }
+    const installed = parseInstalledEntries(raw.installed);
+    if (installed)
+        config.installed = installed;
+    const registries = parseRegistriesConfig(raw.registries);
+    if (registries)
+        config.registries = registries;
     const output = parseOutputConfig(raw.output);
     if (output)
         config.output = output;
@@ -273,23 +265,20 @@ function parseLlmConfig(value) {
     }
     return result;
 }
-function parseRegistryConfig(value) {
-    if (typeof value !== "object" || value === null || Array.isArray(value))
+function parseInstalledEntries(value) {
+    if (!Array.isArray(value))
         return undefined;
-    const obj = value;
-    if (!Array.isArray(obj.installed))
-        return undefined;
-    const installed = obj.installed
-        .map((entry) => parseRegistryInstalledEntry(entry))
+    const entries = value
+        .map((entry) => parseInstalledKitEntry(entry))
         .filter((entry) => entry !== undefined);
-    return { installed };
+    return entries.length > 0 ? entries : undefined;
 }
-function parseRegistryInstalledEntry(value) {
+function parseInstalledKitEntry(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
     const obj = value;
     const id = asNonEmptyString(obj.id);
-    const source = asRegistrySource(obj.source);
+    const source = asKitSource(obj.source);
     const ref = asNonEmptyString(obj.ref);
     const artifactUrl = asNonEmptyString(obj.artifactUrl);
     const stashRoot = asNonEmptyString(obj.stashRoot);
@@ -317,8 +306,39 @@ function parseRegistryInstalledEntry(value) {
 function asNonEmptyString(value) {
     return typeof value === "string" && value ? value : undefined;
 }
-function asRegistrySource(value) {
+function asKitSource(value) {
     if (value === "npm" || value === "github" || value === "git" || value === "local")
         return value;
     return undefined;
 }
+function parseRegistriesConfig(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const entries = value
+        .map((entry) => parseRegistryConfigEntry(entry))
+        .filter((entry) => entry !== undefined);
+    // Return the array even if empty — an explicit empty array means "no registries"
+    // which overrides the default. Only return undefined if the field was not an array.
+    return entries;
+}
+function parseRegistryConfigEntry(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    const url = asNonEmptyString(obj.url);
+    if (!url || !url.startsWith("http"))
+        return undefined;
+    const entry = { url };
+    const name = asNonEmptyString(obj.name);
+    if (name)
+        entry.name = name;
+    if (typeof obj.enabled === "boolean")
+        entry.enabled = obj.enabled;
+    const provider = asNonEmptyString(obj.provider);
+    if (provider)
+        entry.provider = provider;
+    if (typeof obj.options === "object" && obj.options !== null && !Array.isArray(obj.options)) {
+        entry.options = obj.options;
+    }
+    return entry;
+}

package/dist/file-context.js

@@ -22,8 +22,8 @@ export function buildFileContext(stashRoot, absPath) {
     const parentDirAbs = path.dirname(absPath);
     const parentDir = path.basename(parentDirAbs);
     // Compute ancestor directory segments from the POSIX relPath's directory portion.
-    // For "tools/azure/deploy/run.sh" the dir portion is "tools/azure/deploy"
-    // which splits into ["tools", "azure", "deploy"].
+    // For "scripts/azure/deploy/run.sh" the dir portion is "scripts/azure/deploy"
+    // which splits into ["scripts", "azure", "deploy"].
     const relDir = toPosix(path.dirname(relPath));
     const ancestorDirs = relDir === "." ? [] : relDir.split("/").filter((seg) => seg.length > 0);
     // Lazy caches
@@ -69,41 +69,16 @@ const matchers = [];
 /** Renderer lookup by name. */
 const renderers = new Map();
 let builtinsInitialized = false;
-/** Pluggable initializer set via `setBuiltinRegistrar`. */
-let builtinRegistrar = null;
-/**
- * Set the function that registers built-in matchers and renderers.
- *
- * This breaks the static import cycle: `file-context.ts` does not need to
- * import `matchers.ts` or `renderers.ts` at the top level. Instead, a
- * one-time call from outside (e.g. the test file or CLI entry) provides the
- * registration callback.
- *
- * If no registrar is set by the time `ensureBuiltinsRegistered` runs, it
- * falls back to a dynamic `require()` for backward compatibility.
- */
-export function setBuiltinRegistrar(fn) {
-    builtinRegistrar = fn;
-}
 /**
  * Ensure that built-in matchers and renderers are registered.
  * Called lazily on first use of runMatchers/getRenderer.
- *
- * Uses the registrar set via `setBuiltinRegistrar`, or falls back to
- * a direct import of the registration modules. The dynamic import
- * avoids a static circular dependency between file-context, renderers,
- * and asset-spec.
  */
 function ensureBuiltinsRegistered() {
     if (builtinsInitialized)
         return;
     builtinsInitialized = true;
-    if (builtinRegistrar) {
-        builtinRegistrar();
-        return;
-    }
     // Lazy inline require avoids a top-level static import cycle.
-    // These are only evaluated once and only when no explicit registrar was set.
+    // These are only evaluated once.
     // eslint-disable-next-line @typescript-eslint/no-require-imports
     const { registerBuiltinMatchers } = require("./matchers");
     // eslint-disable-next-line @typescript-eslint/no-require-imports

package/dist/indexer.js

@@ -1,9 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
-import { deriveCanonicalAssetName, TYPE_DIRS } from "./asset-spec";
 import { resolveStashDir } from "./common";
 import { closeDatabase, DB_VERSION, deleteEntriesByDir, getEntriesByDir, getEntryCount, getMeta, isVecAvailable, openDatabase, rebuildFts, setMeta, upsertEmbedding, upsertEntry, warnIfVecMissing, } from "./db";
-import { buildFileContext } from "./file-context";
 import { generateMetadataFlat, loadStashFile } from "./metadata";
 import { getDbPath } from "./paths";
 import { walkStashFlat } from "./walker";
@@ -128,10 +126,6 @@ function indexEntries(db, allStashDirs, _stashDir, isIncremental, builtAtMs) {
                 // Try loading existing .stash.json (user metadata overrides)
                 let stash = loadStashFile(dirPath);
                 if (stash) {
-                    // Re-derive canonical names for generated entries using the matcher system.
-                    // This fixes legacy .stash.json files that may have stale names (e.g. "SKILL"
-                    // instead of the directory-based canonical name "code-review").
-                    fixGeneratedEntryNames(stash, files, currentStashDir);
                     // Check for files on disk that aren't covered by existing .stash.json entries.
                     const coveredFiles = new Set(stash.entries.map((e) => (e.filename ? path.basename(e.filename) : "")).filter((e) => !!e));
                     const uncoveredFiles = files.filter((f) => !coveredFiles.has(path.basename(f)));
@@ -226,30 +220,6 @@ function attachFileSize(entry, entryPath) {
     }
 }
 /** Set of all known type directory names */
-const TYPE_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
-/**
- * Re-derive canonical names for generated skill .stash.json entries.
- *
- * Legacy .stash.json files for skills may have name "SKILL" (derived from the
- * filename SKILL.md) instead of the canonical directory name (e.g. "code-review").
- * This fixes those names using the matcher system.
- */
-function fixGeneratedEntryNames(stash, files, stashRoot) {
-    const fileByBaseName = new Map(files.map((f) => [path.basename(f), f]));
-    for (const entry of stash.entries) {
-        if (entry.quality !== "generated" || entry.type !== "skill")
-            continue;
-        const filePath = entry.filename ? fileByBaseName.get(path.basename(entry.filename)) : undefined;
-        if (!filePath)
-            continue;
-        const firstAncestor = buildFileContext(stashRoot, filePath).ancestorDirs[0];
-        const effectiveRoot = firstAncestor && TYPE_DIR_NAMES.has(firstAncestor) ? path.join(stashRoot, firstAncestor) : stashRoot;
-        const canonicalName = deriveCanonicalAssetName("skill", effectiveRoot, filePath);
-        if (canonicalName && canonicalName !== entry.name) {
-            entry.name = canonicalName;
-        }
-    }
-}
 function isDirStale(dirPath, currentFiles, previousEntries, builtAtMs) {
     // Check if file set changed (additions or deletions)
     const prevFileNames = new Set(previousEntries.map((ie) => ie.entry.filename).filter((e) => !!e));

package/dist/llm.js

@@ -22,7 +22,7 @@ async function chatCompletion(config, messages) {
     return json.choices?.[0]?.message?.content?.trim() ?? "";
 }
 // ── Metadata Enhancement ────────────────────────────────────────────────────
-const SYSTEM_PROMPT = `You are a metadata generator for a developer tool registry. Given a tool/skill/command/agent entry, generate improved metadata. Respond with ONLY valid JSON, no markdown fencing.`;
+const SYSTEM_PROMPT = `You are a metadata generator for a developer asset registry. Given a script/skill/command/agent entry, generate improved metadata. Respond with ONLY valid JSON, no markdown fencing.`;
 /**
  * Use an LLM to enhance a stash entry's metadata: improve description,
  * generate searchHints, and suggest tags.

package/dist/matchers.js

@@ -16,7 +16,7 @@
  *   at specificity 5 when no signals are found. Command signals (`agent`
  *   frontmatter, `$ARGUMENTS`/`$1`-`$3` placeholders) return 18.
  */
-import { SCRIPT_EXTENSIONS_BROAD } from "./asset-spec";
+import { SCRIPT_EXTENSIONS } from "./asset-spec";
 import { registerMatcher } from "./file-context";
 // ── extensionMatcher (specificity: 3) ────────────────────────────────────────
 /**
@@ -36,7 +36,7 @@ export function extensionMatcher(ctx) {
         return { type: "skill", specificity: 25, renderer: "skill-md" };
     }
     // Known script extensions (excluding .md, handled by smartMdMatcher)
-    if (SCRIPT_EXTENSIONS_BROAD.has(ctx.ext)) {
+    if (SCRIPT_EXTENSIONS.has(ctx.ext)) {
         return { type: "script", specificity: 3, renderer: "script-source" };
     }
     return null;
@@ -45,19 +45,13 @@ export function extensionMatcher(ctx) {
 /**
  * Directory-based matcher that boosts specificity when the first ancestor
  * directory segment from the stash root matches a known type name.
- *
- * Accepts ALL known script extensions in both `tools/` and `scripts/`
- * directories -- the distinction is purely organizational.
  */
 export function directoryMatcher(ctx) {
     const topDir = ctx.ancestorDirs[0];
     if (!topDir)
         return null;
     const ext = ctx.ext;
-    if (topDir === "tools" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
-        return { type: "tool", specificity: 10, renderer: "script-source" };
-    }
-    if (topDir === "scripts" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
+    if (topDir === "scripts" && SCRIPT_EXTENSIONS.has(ext)) {
         return { type: "script", specificity: 10, renderer: "script-source" };
     }
     if (topDir === "skills" && ctx.fileName === "SKILL.md") {
@@ -80,15 +74,10 @@ export function directoryMatcher(ctx) {
  * the ancestor-based directory matcher because the file might be nested
  * several levels deep, yet its immediate parent can still carry strong
  * naming conventions (e.g. `my-project/agents/planning.md`).
- *
- * Accepts ALL known script extensions in both `tools/` and `scripts/`.
  */
 export function parentDirHintMatcher(ctx) {
     const { parentDir, ext, fileName } = ctx;
-    if (parentDir === "tools" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
-        return { type: "tool", specificity: 15, renderer: "script-source" };
-    }
-    if (parentDir === "scripts" && SCRIPT_EXTENSIONS_BROAD.has(ext)) {
+    if (parentDir === "scripts" && SCRIPT_EXTENSIONS.has(ext)) {
         return { type: "script", specificity: 15, renderer: "script-source" };
     }
     if (parentDir === "skills" && fileName === "SKILL.md") {

package/dist/metadata.js

@@ -176,7 +176,7 @@ export function generateMetadata(dirPath, assetType, files, typeRoot = dirPath)
                 entry.confidence = 0.9;
             }
         }
-        // Priority 3: Type-specific metadata extraction (e.g. TOC for knowledge, comments for tools/scripts)
+        // Priority 3: Type-specific metadata extraction (e.g. TOC for knowledge, comments for scripts)
         const fileCtx = buildFileContext(typeRoot, file);
         const match = runMatchers(fileCtx);
         if (match) {
@@ -204,7 +204,7 @@ export function generateMetadata(dirPath, assetType, files, typeRoot = dirPath)
     }
     return { entries };
 }
-/** Set of all known type directory names (e.g. "tools", "skills", "scripts") */
+/** Set of all known type directory names (e.g. "scripts", "skills", "agents") */
 const TYPE_DIR_NAMES = new Set(Object.values(TYPE_DIRS));
 /**
  * Generate metadata for files using the matcher system instead of a fixed asset type.
@@ -226,7 +226,7 @@ export function generateMetadataFlat(stashRoot, files) {
             continue;
         // If the file lives under a known type directory, use that as the root
         // for canonical naming so names don't include the type prefix.
-        // e.g. tools/deploy.sh → "deploy.sh" not "tools/deploy.sh"
+        // e.g. scripts/deploy.sh → "deploy.sh" not "scripts/deploy.sh"
         const firstAncestor = ctx.ancestorDirs[0];
         const effectiveRoot = firstAncestor && TYPE_DIR_NAMES.has(firstAncestor) ? path.join(stashRoot, firstAncestor) : stashRoot;
         const ext = path.extname(file).toLowerCase();

package/dist/provider-registry.js

@@ -0,0 +1,8 @@
+// ── Factory map ─────────────────────────────────────────────────────────────
+const providers = new Map();
+export function registerProvider(type, factory) {
+    providers.set(type, factory);
+}
+export function resolveProviderFactory(type) {
+    return providers.get(type) ?? null;
+}

package/dist/providers/skills-sh.js

@@ -0,0 +1,165 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fetchWithRetry } from "../common";
+import { getRegistryIndexCacheDir } from "../paths";
+import { registerProvider } from "../provider-registry";
+// ── Constants ───────────────────────────────────────────────────────────────
+/** Per-query cache TTL in milliseconds (15 minutes). */
+const QUERY_CACHE_TTL_MS = 15 * 60 * 1000;
+/** Maximum age before query cache is considered stale but still usable (1 day). */
+const QUERY_CACHE_STALE_MS = 24 * 60 * 60 * 1000;
+// ── Provider class ──────────────────────────────────────────────────────────
+class SkillsShProvider {
+    type = "skills-sh";
+    config;
+    constructor(config) {
+        this.config = config;
+    }
+    async search(options) {
+        try {
+            const entries = await this.fetchSkills(options.query, options.limit);
+            const limited = entries.slice(0, options.limit);
+            const hits = this.mapToHits(limited);
+            let assetHits;
+            if (options.includeAssets) {
+                assetHits = this.mapToAssetHits(limited);
+            }
+            return { hits, assetHits };
+        }
+        catch (err) {
+            const label = this.config.name ?? "skills.sh";
+            const message = err instanceof Error ? err.message : String(err);
+            return { hits: [], warnings: [`Registry ${label}: ${message}`] };
+        }
+    }
+    async fetchSkills(query, limit) {
+        // Check per-query cache first
+        const cachePath = this.queryCachePath(query, limit);
+        const cached = this.readQueryCache(cachePath);
+        if (cached && !isExpired(cached.mtime, QUERY_CACHE_TTL_MS)) {
+            return cached.entries;
+        }
+        // Fetch from API
+        const baseUrl = this.config.url.replace(/\/+$/, "");
+        const url = `${baseUrl}/api/search?q=${encodeURIComponent(query)}&limit=${limit}`;
+        try {
+            const response = await fetchWithRetry(url, undefined, { timeout: 10_000, retries: 1 });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}`);
+            }
+            const data = (await response.json());
+            const entries = parseSkillsResponse(data);
+            this.writeQueryCache(cachePath, entries);
+            return entries;
+        }
+        catch (err) {
+            // Fall back to stale cache if available
+            if (cached && !isExpired(cached.mtime, QUERY_CACHE_STALE_MS)) {
+                return cached.entries;
+            }
+            throw err;
+        }
+    }
+    mapToHits(entries) {
+        if (entries.length === 0)
+            return [];
+        // Assign decreasing synthetic scores for merge compatibility
+        const maxInstalls = Math.max(...entries.map((e) => e.installs), 1);
+        const registryName = this.config.name ?? "skills.sh";
+        const baseUrl = this.config.url.replace(/\/+$/, "");
+        return entries.map((entry) => {
+            const owner = entry.source.split("/")[0] ?? "";
+            const score = Math.round((entry.installs / maxInstalls) * 1000) / 1000;
+            return {
+                source: "github",
+                id: `skills-sh:${entry.id}`,
+                title: entry.name,
+                ref: entry.source,
+                homepage: `${baseUrl}/${entry.id}`,
+                score,
+                metadata: {
+                    installs: String(entry.installs),
+                    ...(owner ? { author: owner } : {}),
+                },
+                registryName,
+            };
+        });
+    }
+    mapToAssetHits(entries) {
+        if (entries.length === 0)
+            return undefined;
+        const registryName = this.config.name ?? "skills.sh";
+        const maxInstalls = Math.max(...entries.map((e) => e.installs), 1);
+        const hits = entries.map((entry) => ({
+            type: "registry-asset",
+            assetType: "skill",
+            assetName: entry.name,
+            kit: { id: `skills-sh:${entry.id}`, name: entry.name },
+            registryName,
+            action: `akm add ${entry.source}`,
+            score: Math.round((entry.installs / maxInstalls) * 1000) / 1000,
+        }));
+        return hits.length > 0 ? hits : undefined;
+    }
+    // ── Per-query cache ─────────────────────────────────────────────────────
+    queryCachePath(query, limit) {
+        const cacheDir = getRegistryIndexCacheDir();
+        const hasher = new Bun.CryptoHasher("md5");
+        hasher.update(this.config.url);
+        hasher.update("\0");
+        hasher.update(query.trim().toLowerCase());
+        hasher.update("\0");
+        hasher.update(String(limit));
+        const hash = hasher.digest("hex");
+        return path.join(cacheDir, `skills-sh-search-${hash}.json`);
+    }
+    readQueryCache(cachePath) {
+        try {
+            const stat = fs.statSync(cachePath);
+            const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"));
+            if (!Array.isArray(raw))
+                return null;
+            const entries = raw.filter(isValidSkillsEntry);
+            return { entries, mtime: stat.mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    }
+    writeQueryCache(cachePath, entries) {
+        try {
+            const dir = path.dirname(cachePath);
+            fs.mkdirSync(dir, { recursive: true });
+            const tmpPath = `${cachePath}.tmp.${process.pid}`;
+            fs.writeFileSync(tmpPath, JSON.stringify(entries), "utf8");
+            fs.renameSync(tmpPath, cachePath);
+        }
+        catch {
+            // Best-effort caching
+        }
+    }
+}
+// ── Self-register ───────────────────────────────────────────────────────────
+registerProvider("skills-sh", (config) => new SkillsShProvider(config));
+// ── Response parsing ────────────────────────────────────────────────────────
+function parseSkillsResponse(data) {
+    if (typeof data !== "object" || data === null || Array.isArray(data))
+        return [];
+    const obj = data;
+    if (!Array.isArray(obj.skills))
+        return [];
+    return obj.skills.filter(isValidSkillsEntry);
+}
+function isValidSkillsEntry(entry) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry))
+        return false;
+    const obj = entry;
+    return (typeof obj.id === "string" &&
+        typeof obj.name === "string" &&
+        typeof obj.installs === "number" &&
+        typeof obj.source === "string");
+}
+// ── Utilities ───────────────────────────────────────────────────────────────
+function isExpired(mtimeMs, ttlMs) {
+    return Date.now() - mtimeMs > ttlMs;
+}