akm-cli 0.0.20 → 0.0.22

package/dist/providers/static-index.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { fetchWithRetry } from "../common";
+import { fetchWithRetry, toErrorMessage } from "../common";
+import { asString } from "../github";
 import { getRegistryIndexCacheDir } from "../paths";
-import { registerProvider } from "../provider-registry";
+import { registerProvider } from "../registry-factory";
 // ── Constants ───────────────────────────────────────────────────────────────
 /** Cache TTL in milliseconds (1 hour). */
 const CACHE_TTL_MS = 60 * 60 * 1000;
@@ -100,7 +101,7 @@ export function writeCachedIndex(cachePath, index) {
     try {
         const dir = path.dirname(cachePath);
         fs.mkdirSync(dir, { recursive: true });
-        const tmpPath = `${cachePath}.tmp.${process.pid}`;
+        const tmpPath = `${cachePath}.tmp.${process.pid}.${Math.random().toString(36).slice(2)}`;
         fs.writeFileSync(tmpPath, JSON.stringify(index), "utf8");
         fs.renameSync(tmpPath, cachePath);
     }
@@ -316,9 +317,6 @@ function scoreAsset(asset, tokens) {
     return tokens.length > 0 ? score / tokens.length : 0;
 }
 // ── Utilities ───────────────────────────────────────────────────────────────
-function asString(value) {
-    return typeof value === "string" && value ? value : undefined;
-}
 function asSource(value) {
     if (value === "npm" || value === "github" || value === "git" || value === "local")
         return value;
@@ -342,6 +340,3 @@ function buildInstallRef(source, ref) {
             return `github:${ref}`;
     }
 }
-function toErrorMessage(error) {
-    return error instanceof Error ? error.message : String(error);
-}

package/dist/registry-build-index.js

@@ -0,0 +1,356 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fetchWithRetry } from "./common";
+import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "./github";
+import { copyIncludedPaths, findNearestIncludeConfig } from "./kit-include";
+import { generateMetadataFlat, loadStashFile } from "./metadata";
+import { parseRegistryIndex } from "./providers/static-index";
+import { detectStashRoot, extractTarGzSecure } from "./registry-install";
+import { walkStashFlat } from "./walker";
+const DEFAULT_NPM_REGISTRY_BASE = "https://registry.npmjs.org";
+const DEFAULT_MANUAL_ENTRIES_PATH = path.resolve("manual-entries.json");
+const DEFAULT_OUTPUT_PATH = path.resolve("index.json");
+const REQUIRED_KEYWORDS = ["agentikit", "akm-kit"];
+const GITHUB_TOPICS = ["agentikit", "akm-kit"];
+const EXCLUDED_REPOS = new Set(["itlackey/agentikit-plugins", "itlackey/agentikit"]);
+const EXCLUDED_NPM_PACKAGES = new Set([
+    "agentikit",
+    "agentikit-claude",
+    "agentikit-opencode",
+    "agentikit-plugins",
+    "akm-cli",
+    "akm-opencode",
+]);
+const EMPTY_INSPECTION = {};
+export async function buildRegistryIndex(options) {
+    const manualEntriesPath = path.resolve(options?.manualEntriesPath ?? DEFAULT_MANUAL_ENTRIES_PATH);
+    const npmRegistryBase = trimTrailingSlash(options?.npmRegistryBase ?? DEFAULT_NPM_REGISTRY_BASE);
+    const githubApiBase = trimTrailingSlash(options?.githubApiBase ?? GITHUB_API_BASE);
+    const [manualKits, npmKits, githubKits] = await Promise.all([
+        loadManualEntries(manualEntriesPath),
+        scanNpm(npmRegistryBase),
+        scanGithub(githubApiBase),
+    ]);
+    const kits = deduplicateKits([...manualKits, ...npmKits, ...githubKits]).sort((a, b) => a.name.localeCompare(b.name));
+    const index = {
+        version: 2,
+        updatedAt: new Date().toISOString(),
+        kits,
+    };
+    return {
+        index,
+        counts: {
+            manual: manualKits.length,
+            npm: npmKits.length,
+            github: githubKits.length,
+            total: kits.length,
+        },
+        paths: {
+            manualEntriesPath,
+        },
+    };
+}
+export function writeRegistryIndex(index, outPath) {
+    const resolved = path.resolve(outPath ?? DEFAULT_OUTPUT_PATH);
+    fs.mkdirSync(path.dirname(resolved), { recursive: true });
+    fs.writeFileSync(resolved, `${JSON.stringify(index, null, 2)}\n`, "utf8");
+    return resolved;
+}
+async function scanNpm(npmRegistryBase) {
+    const kits = [];
+    const seen = new Set();
+    for (const keyword of REQUIRED_KEYWORDS) {
+        let offset = 0;
+        const size = 250;
+        while (true) {
+            const url = `${npmRegistryBase}/-/v1/search?text=keywords:${encodeURIComponent(keyword)}&size=${size}&from=${offset}`;
+            const data = await fetchJson(url);
+            for (const obj of data.objects) {
+                const pkg = obj.package;
+                if (EXCLUDED_NPM_PACKAGES.has(pkg.name))
+                    continue;
+                const repoUrl = pkg.links?.repository ?? "";
+                const normalizedRepo = repoUrl.replace(/^https?:\/\/github\.com\//, "").replace(/\.git$/, "");
+                if (EXCLUDED_REPOS.has(normalizedRepo))
+                    continue;
+                const id = `npm:${pkg.name}`;
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                const keywords = (pkg.keywords ?? []).map((value) => value.toLowerCase());
+                if (!keywords.some((value) => REQUIRED_KEYWORDS.includes(value)))
+                    continue;
+                let latestMetadata = {};
+                try {
+                    latestMetadata = await fetchJson(`${npmRegistryBase}/${encodeURIComponent(pkg.name)}/latest`);
+                }
+                catch {
+                    latestMetadata = {};
+                }
+                const inspection = await inspectNpmPackage(npmRegistryBase, latestMetadata).catch(() => EMPTY_INSPECTION);
+                const tags = mergeStrings((pkg.keywords ?? []).filter((value) => !REQUIRED_KEYWORDS.includes(value.toLowerCase())), inspection.tags);
+                kits.push(normalizeKit({
+                    id,
+                    name: pkg.name,
+                    description: inspection.description ?? pkg.description,
+                    ref: pkg.name,
+                    source: "npm",
+                    homepage: pkg.links?.homepage ?? pkg.links?.npm,
+                    author: pkg.author?.name ?? pkg.author?.username ?? pkg.publisher?.username,
+                    latestVersion: inspection.latestVersion ?? pkg.version,
+                    license: asString(latestMetadata.license) ?? inspection.license,
+                    tags,
+                    assetTypes: inspection.assetTypes,
+                    assets: inspection.assets,
+                }));
+            }
+            if (data.objects.length < size)
+                break;
+            offset += size;
+        }
+    }
+    return kits;
+}
+async function inspectNpmPackage(_npmRegistryBase, latestMetadata) {
+    const dist = asRecord(latestMetadata.dist);
+    const tarballUrl = asString(dist.tarball);
+    if (!tarballUrl)
+        return {};
+    const inspection = await inspectArchive(tarballUrl);
+    return {
+        description: asString(latestMetadata.description) ?? inspection.description,
+        latestVersion: asString(latestMetadata.version) ?? inspection.latestVersion,
+        license: asString(latestMetadata.license) ?? inspection.license,
+        tags: mergeStrings(extractNonReservedKeywords(latestMetadata.keywords), inspection.tags),
+        assetTypes: inspection.assetTypes,
+        assets: inspection.assets,
+    };
+}
+async function scanGithub(githubApiBase) {
+    const kits = [];
+    const seen = new Set();
+    const headers = githubHeaders();
+    for (const topic of GITHUB_TOPICS) {
+        let page = 1;
+        const perPage = 100;
+        while (true) {
+            const q = encodeURIComponent(`topic:${topic}`);
+            const url = `${githubApiBase}/search/repositories?q=${q}&sort=updated&order=desc&per_page=${perPage}&page=${page}`;
+            const data = await fetchJson(url, headers);
+            for (const repo of data.items) {
+                if (EXCLUDED_REPOS.has(repo.full_name))
+                    continue;
+                const id = `github:${repo.full_name}`;
+                if (seen.has(id))
+                    continue;
+                seen.add(id);
+                const inspection = await inspectArchive(`${githubApiBase}/repos/${repo.full_name}/tarball/${encodeURIComponent(repo.default_branch)}`, headers).catch(() => EMPTY_INSPECTION);
+                const topics = repo.topics.filter((value) => !GITHUB_TOPICS.includes(value));
+                kits.push(normalizeKit({
+                    id,
+                    name: repo.name,
+                    description: inspection.description ?? repo.description ?? undefined,
+                    ref: repo.full_name,
+                    source: "github",
+                    homepage: repo.html_url,
+                    author: repo.owner.login,
+                    latestVersion: inspection.latestVersion,
+                    license: repo.license?.spdx_id ?? inspection.license,
+                    tags: mergeStrings(topics, inspection.tags),
+                    assetTypes: inspection.assetTypes,
+                    assets: inspection.assets,
+                }));
+            }
+            if (data.items.length < perPage)
+                break;
+            page += 1;
+        }
+    }
+    return kits;
+}
+async function inspectArchive(url, headers) {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "akm-registry-build-"));
+    const archivePath = path.join(tempDir, "archive.tgz");
+    const extractDir = path.join(tempDir, "extract");
+    try {
+        const response = await fetchWithRetry(url, headers ? { headers } : undefined, { timeout: 120_000 });
+        if (!response.ok) {
+            throw new Error(`Failed to fetch archive (${response.status}) from ${url}`);
+        }
+        await Bun.write(archivePath, response);
+        // Reuse the secure extraction from registry-install which validates entries,
+        // uses --no-same-owner, strips components, and runs a post-extraction scan.
+        extractTarGzSecure(archivePath, extractDir);
+        const stashRoot = detectStashRoot(extractDir);
+        const inspectionRoot = applyIncludeConfigForInspection(stashRoot, tempDir, extractDir) ?? stashRoot;
+        const metadata = await enumerateAssets(inspectionRoot);
+        const packageMetadata = readNearestPackageJson(extractDir, inspectionRoot);
+        const assets = metadata.map((entry) => ({
+            type: entry.type,
+            name: entry.name,
+            ...(entry.description ? { description: entry.description } : {}),
+            ...(entry.tags && entry.tags.length > 0 ? { tags: entry.tags } : {}),
+        }));
+        return {
+            description: asString(packageMetadata.description),
+            latestVersion: asString(packageMetadata.version),
+            license: asString(packageMetadata.license),
+            tags: extractNonReservedKeywords(packageMetadata.keywords),
+            assetTypes: deriveAssetTypes(assets),
+            assets: assets.length > 0 ? assets : undefined,
+        };
+    }
+    finally {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    }
+}
+function readNearestPackageJson(extractDir, stashRoot) {
+    const candidates = [
+        path.join(stashRoot, "package.json"),
+        path.join(extractDir, "package.json"),
+        path.join(extractDir, "package", "package.json"),
+    ];
+    for (const candidate of candidates) {
+        try {
+            return asRecord(JSON.parse(fs.readFileSync(candidate, "utf8")));
+        }
+        catch { }
+    }
+    return {};
+}
+async function enumerateAssets(stashRoot) {
+    const fileContexts = walkStashFlat(stashRoot);
+    const dirGroups = new Map();
+    for (const ctx of fileContexts) {
+        const group = dirGroups.get(ctx.parentDirAbs);
+        if (group)
+            group.push(ctx.absPath);
+        else
+            dirGroups.set(ctx.parentDirAbs, [ctx.absPath]);
+    }
+    const entries = [];
+    for (const [dirPath, files] of dirGroups) {
+        let stash = loadStashFile(dirPath);
+        if (stash) {
+            const covered = new Set(stash.entries.map((entry) => entry.filename).filter((value) => !!value));
+            const uncoveredFiles = files.filter((file) => !covered.has(path.basename(file)));
+            if (uncoveredFiles.length > 0) {
+                const generated = await generateMetadataFlat(stashRoot, uncoveredFiles);
+                if (generated.entries.length > 0) {
+                    stash = { entries: [...stash.entries, ...generated.entries] };
+                }
+            }
+        }
+        else {
+            const generated = await generateMetadataFlat(stashRoot, files);
+            if (generated.entries.length === 0)
+                continue;
+            stash = generated;
+        }
+        entries.push(...stash.entries);
+    }
+    return entries.sort((a, b) => `${a.type}:${a.name}`.localeCompare(`${b.type}:${b.name}`));
+}
+function applyIncludeConfigForInspection(stashRoot, tempDir, searchRoot) {
+    const includeConfig = findNearestIncludeConfig(stashRoot, searchRoot);
+    if (!includeConfig)
+        return undefined;
+    const selectedDir = path.join(tempDir, "selected");
+    fs.rmSync(selectedDir, { recursive: true, force: true });
+    fs.mkdirSync(selectedDir, { recursive: true });
+    copyIncludedPaths(includeConfig.include, includeConfig.baseDir, selectedDir);
+    return selectedDir;
+}
+async function loadManualEntries(manualEntriesPath) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(manualEntriesPath, "utf8"));
+        const candidateKits = Array.isArray(raw) ? raw : asRecord(raw).kits;
+        const parsed = parseRegistryIndex({ version: 2, updatedAt: new Date().toISOString(), kits: candidateKits });
+        if (!parsed)
+            return [];
+        return parsed.kits.map((kit) => normalizeKit({ ...kit, curated: kit.curated ?? true }));
+    }
+    catch {
+        return [];
+    }
+}
+async function fetchJson(url, headers) {
+    const response = await fetchWithRetry(url, headers ? { headers } : undefined, { timeout: 30_000 });
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`HTTP ${response.status} from ${url}: ${body.slice(0, 200)}`);
+    }
+    return (await response.json());
+}
+function deduplicateKits(kits) {
+    const byId = new Map();
+    for (const kit of kits) {
+        const existing = byId.get(kit.id);
+        byId.set(kit.id, existing ? mergeEntries(existing, kit) : kit);
+    }
+    return [...byId.values()];
+}
+function mergeEntries(a, b) {
+    const assets = mergeAssets(a.assets, b.assets);
+    const assetTypes = mergeStrings(a.assetTypes, b.assetTypes, assets ? deriveAssetTypes(assets) : undefined);
+    return normalizeKit({
+        id: a.id,
+        name: a.name,
+        description: a.description ?? b.description,
+        ref: a.ref,
+        source: a.source,
+        homepage: a.homepage ?? b.homepage,
+        tags: mergeStrings(a.tags, b.tags),
+        assetTypes,
+        assets,
+        author: a.author ?? b.author,
+        license: a.license ?? b.license,
+        latestVersion: a.latestVersion ?? b.latestVersion,
+        curated: a.curated || b.curated || undefined,
+    });
+}
+function mergeAssets(a, b) {
+    if (!a && !b)
+        return undefined;
+    const merged = new Map();
+    for (const asset of [...(a ?? []), ...(b ?? [])]) {
+        const key = `${asset.type}:${asset.name}`;
+        if (!merged.has(key))
+            merged.set(key, asset);
+    }
+    const values = [...merged.values()];
+    return values.length > 0 ? sortAssets(values) : undefined;
+}
+function mergeStrings(...values) {
+    const merged = [...new Set(values.flatMap((value) => value ?? []).filter((value) => value.trim().length > 0))].sort();
+    return merged.length > 0 ? merged : undefined;
+}
+function deriveAssetTypes(assets) {
+    return mergeStrings(assets?.map((asset) => asset.type));
+}
+function extractNonReservedKeywords(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const filtered = value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0)
+        .filter((item) => !REQUIRED_KEYWORDS.includes(item.toLowerCase()));
+    return filtered.length > 0 ? filtered : undefined;
+}
+function normalizeKit(kit) {
+    const assets = kit.assets ? sortAssets(kit.assets) : undefined;
+    return {
+        ...kit,
+        ...(kit.tags && kit.tags.length > 0 ? { tags: kit.tags } : {}),
+        ...(kit.assetTypes && kit.assetTypes.length > 0 ? { assetTypes: kit.assetTypes } : {}),
+        ...(assets && assets.length > 0 ? { assets } : {}),
+    };
+}
+function sortAssets(assets) {
+    return [...assets].sort((a, b) => `${a.type}:${a.name}`.localeCompare(`${b.type}:${b.name}`));
+}
+function trimTrailingSlash(value) {
+    return value.replace(/\/+$/, "");
+}

package/dist/registry-factory.js

@@ -0,0 +1,19 @@
+/**
+ * Registry provider factory map.
+ *
+ * Maps registry provider type identifiers (e.g. "static-index", "skills-sh")
+ * to factory functions that create RegistryProvider instances.
+ *
+ * "Registry" here refers to the kit discovery registries (npm, GitHub, static
+ * index files) — not to be confused with the stash provider factory map in
+ * stash-provider-factory.ts or the installed-kit operations in installed-kits.ts.
+ */
+import { createProviderRegistry } from "./create-provider-registry";
+// ── Factory map ─────────────────────────────────────────────────────────────
+const registry = createProviderRegistry();
+export function registerProvider(type, factory) {
+    registry.register(type, factory);
+}
+export function resolveProviderFactory(type) {
+    return registry.resolve(type);
+}