agentpacks 0.2.0

package/dist/cli/install.js

@@ -0,0 +1,610 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __moduleCache = /* @__PURE__ */ new WeakMap;
+var __toCommonJS = (from) => {
+  var entry = __moduleCache.get(from), desc;
+  if (entry)
+    return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if (from && typeof from === "object" || typeof from === "function")
+    __getOwnPropNames(from).map((key) => !__hasOwnProp.call(entry, key) && __defProp(entry, key, {
+      get: () => from[key],
+      enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+    }));
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __require = import.meta.require;
+
+// src/core/config.ts
+var exports_config = {};
+__export(exports_config, {
+  resolveTargets: () => resolveTargets,
+  resolveFeatures: () => resolveFeatures,
+  loadWorkspaceConfig: () => loadWorkspaceConfig,
+  loadPackManifest: () => loadPackManifest,
+  WorkspaceConfigSchema: () => WorkspaceConfigSchema,
+  TARGET_IDS: () => TARGET_IDS,
+  REPO_MODES: () => REPO_MODES,
+  PackManifestSchema: () => PackManifestSchema,
+  FEATURE_IDS: () => FEATURE_IDS
+});
+import { z } from "zod";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { parse as parseJsonc } from "jsonc-parser";
+function loadWorkspaceConfig(projectRoot) {
+  for (const filename of CONFIG_FILES) {
+    const filepath = resolve(projectRoot, filename);
+    if (existsSync(filepath)) {
+      const raw = readFileSync(filepath, "utf-8");
+      const parsed = parseJsonc(raw);
+      return WorkspaceConfigSchema.parse(parsed);
+    }
+  }
+  return WorkspaceConfigSchema.parse({});
+}
+function loadPackManifest(packDir) {
+  const filepath = resolve(packDir, "pack.json");
+  if (!existsSync(filepath)) {
+    const dirName = packDir.split("/").pop() ?? "unknown";
+    return PackManifestSchema.parse({ name: dirName });
+  }
+  const raw = readFileSync(filepath, "utf-8");
+  const parsed = JSON.parse(raw);
+  return PackManifestSchema.parse(parsed);
+}
+function resolveFeatures(config, targetId) {
+  const { features } = config;
+  if (features === "*") {
+    return [...FEATURE_IDS];
+  }
+  if (Array.isArray(features)) {
+    if (features.includes("*"))
+      return [...FEATURE_IDS];
+    return features.filter((f) => FEATURE_IDS.includes(f));
+  }
+  const targetFeatures = features[targetId];
+  if (!targetFeatures)
+    return [];
+  if (targetFeatures === "*")
+    return [...FEATURE_IDS];
+  if (Array.isArray(targetFeatures) && targetFeatures.includes("*"))
+    return [...FEATURE_IDS];
+  return targetFeatures.filter((f) => FEATURE_IDS.includes(f));
+}
+function resolveTargets(config) {
+  if (config.targets === "*")
+    return [...TARGET_IDS];
+  return config.targets;
+}
+var TARGET_IDS, FEATURE_IDS, REPO_MODES, PackManifestSchema, FeaturesSchema, WorkspaceConfigSchema, CONFIG_FILES;
+var init_config = __esm(() => {
+  TARGET_IDS = [
+    "opencode",
+    "cursor",
+    "claudecode",
+    "codexcli",
+    "geminicli",
+    "copilot",
+    "agentsmd",
+    "cline",
+    "kilo",
+    "roo",
+    "qwencode",
+    "kiro",
+    "factorydroid",
+    "antigravity",
+    "junie",
+    "augmentcode",
+    "windsurf",
+    "warp",
+    "replit",
+    "zed"
+  ];
+  FEATURE_IDS = [
+    "rules",
+    "commands",
+    "agents",
+    "skills",
+    "hooks",
+    "plugins",
+    "mcp",
+    "ignore"
+  ];
+  REPO_MODES = ["repo", "monorepo", "metarepo"];
+  PackManifestSchema = z.object({
+    name: z.string().min(1),
+    version: z.string().default("1.0.0"),
+    description: z.string().default(""),
+    author: z.union([
+      z.string(),
+      z.object({ name: z.string(), email: z.string().optional() })
+    ]).optional(),
+    tags: z.array(z.string()).default([]),
+    dependencies: z.array(z.string()).default([]),
+    conflicts: z.array(z.string()).default([]),
+    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+    features: z.union([z.literal("*"), z.array(z.string())]).default("*")
+  });
+  FeaturesSchema = z.union([
+    z.literal("*"),
+    z.array(z.string()),
+    z.record(z.string(), z.union([z.literal("*"), z.array(z.string())]))
+  ]);
+  WorkspaceConfigSchema = z.object({
+    $schema: z.string().optional(),
+    packs: z.array(z.string()).default(["./packs/default"]),
+    disabled: z.array(z.string()).default([]),
+    targets: z.union([z.literal("*"), z.array(z.string())]).default("*"),
+    features: FeaturesSchema.default("*"),
+    mode: z.enum(REPO_MODES).default("repo"),
+    baseDirs: z.array(z.string()).default(["."]),
+    global: z.boolean().default(false),
+    delete: z.boolean().default(true),
+    verbose: z.boolean().default(false),
+    silent: z.boolean().default(false),
+    overrides: z.record(z.string(), z.record(z.string(), z.string())).default({}),
+    sources: z.array(z.object({
+      source: z.string(),
+      packs: z.array(z.string()).optional(),
+      skills: z.array(z.string()).optional()
+    })).default([])
+  });
+  CONFIG_FILES = ["agentpacks.local.jsonc", "agentpacks.jsonc"];
+});
+
+// src/core/lockfile.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+import { createHash } from "crypto";
+var LOCKFILE_VERSION = 1;
+var LOCKFILE_NAME = "agentpacks.lock";
+function loadLockfile(projectRoot) {
+  const filepath = resolve2(projectRoot, LOCKFILE_NAME);
+  if (!existsSync2(filepath)) {
+    return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
+  }
+  const raw = readFileSync2(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveLockfile(projectRoot, lockfile) {
+  const filepath = resolve2(projectRoot, LOCKFILE_NAME);
+  writeFileSync(filepath, JSON.stringify(lockfile, null, 2) + `
+`);
+}
+function getLockedSource(lockfile, sourceKey) {
+  return lockfile.sources[sourceKey];
+}
+function setLockedSource(lockfile, sourceKey, entry) {
+  lockfile.sources[sourceKey] = entry;
+}
+function computeIntegrity(content) {
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256-${hash}`;
+}
+function isLockfileFrozenValid(lockfile, sourceKeys) {
+  const missing = sourceKeys.filter((key) => !(key in lockfile.sources));
+  return { valid: missing.length === 0, missing };
+}
+
+// src/sources/local.ts
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3, isAbsolute } from "path";
+function resolveLocalPack(packRef, projectRoot) {
+  let resolved;
+  if (isAbsolute(packRef)) {
+    resolved = packRef;
+  } else {
+    resolved = resolve3(projectRoot, packRef);
+  }
+  if (!existsSync3(resolved))
+    return null;
+  return resolved;
+}
+function isLocalPackRef(packRef) {
+  return packRef.startsWith("./") || packRef.startsWith("../") || isAbsolute(packRef);
+}
+
+// src/sources/git-ref.ts
+function parseGitSourceRef(source) {
+  let s = source;
+  if (s.startsWith("github:")) {
+    s = s.slice(7);
+  }
+  let path = "";
+  const atIdx = s.indexOf("@");
+  const colonIdx = s.indexOf(":", atIdx > -1 ? atIdx : 0);
+  if (colonIdx > -1) {
+    path = s.slice(colonIdx + 1);
+    s = s.slice(0, colonIdx);
+  }
+  let ref = "main";
+  if (atIdx > -1) {
+    ref = s.slice(atIdx + 1);
+    s = s.slice(0, atIdx);
+  }
+  const parts = s.split("/");
+  if (parts.length < 2) {
+    throw new Error(`Invalid git source reference: "${source}". Expected owner/repo format.`);
+  }
+  return {
+    owner: parts[0],
+    repo: parts[1],
+    ref,
+    path: path || ""
+  };
+}
+function isGitPackRef(packRef) {
+  if (packRef.startsWith("github:"))
+    return true;
+  if (packRef.startsWith("./") || packRef.startsWith("../") || packRef.startsWith("/")) {
+    return false;
+  }
+  if (packRef.startsWith("@") || packRef.startsWith("npm:"))
+    return false;
+  const parts = packRef.split("/");
+  return parts.length === 2 && !packRef.includes("node_modules");
+}
+function gitSourceKey(parsed) {
+  return `${parsed.owner}/${parsed.repo}`;
+}
+
+// src/sources/npm-ref.ts
+function parseNpmSourceRef(source) {
+  let s = source;
+  if (s.startsWith("npm:")) {
+    s = s.slice(4);
+  }
+  let path = "";
+  const pathColonIdx = findPathColon(s);
+  if (pathColonIdx > -1) {
+    path = s.slice(pathColonIdx + 1);
+    s = s.slice(0, pathColonIdx);
+  }
+  let version = "latest";
+  const versionAtIdx = findVersionAt(s);
+  if (versionAtIdx > -1) {
+    version = s.slice(versionAtIdx + 1);
+    s = s.slice(0, versionAtIdx);
+  }
+  if (!s) {
+    throw new Error(`Invalid npm source reference: "${source}". Expected package name.`);
+  }
+  return { packageName: s, version, path };
+}
+function findPathColon(s) {
+  const startAfter = s.startsWith("@") ? s.indexOf("/") + 1 : 0;
+  const vAt = findVersionAt(s);
+  const searchFrom = vAt > -1 ? vAt : startAfter;
+  return s.indexOf(":", searchFrom);
+}
+function findVersionAt(s) {
+  if (s.startsWith("@")) {
+    const slashIdx = s.indexOf("/");
+    if (slashIdx === -1)
+      return -1;
+    return s.indexOf("@", slashIdx + 1);
+  }
+  return s.indexOf("@");
+}
+function isNpmPackRef(packRef) {
+  if (packRef.startsWith("npm:"))
+    return true;
+  if (packRef.startsWith("@") && packRef.includes("/"))
+    return true;
+  return false;
+}
+function npmSourceKey(parsed) {
+  return `npm:${parsed.packageName}`;
+}
+
+// src/sources/git.ts
+import { mkdirSync, writeFileSync as writeFileSync2 } from "fs";
+import { resolve as resolve4, join } from "path";
+var GITHUB_API = "https://api.github.com";
+function githubHeaders(token) {
+  const h = {
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "agentpacks"
+  };
+  if (token)
+    h.Authorization = `token ${token}`;
+  return h;
+}
+async function resolveGitRef(parsed, token) {
+  const base = `${GITHUB_API}/repos/${parsed.owner}/${parsed.repo}/git/ref`;
+  const res = await fetch(`${base}/heads/${parsed.ref}`, {
+    headers: githubHeaders(token)
+  });
+  if (!res.ok) {
+    const tagRes = await fetch(`${base}/tags/${parsed.ref}`, {
+      headers: githubHeaders(token)
+    });
+    if (!tagRes.ok) {
+      throw new Error(`Could not resolve ref "${parsed.ref}" for ${parsed.owner}/${parsed.repo}: ${res.status}`);
+    }
+    const tagData = await tagRes.json();
+    return tagData.object.sha;
+  }
+  const data = await res.json();
+  return data.object.sha;
+}
+async function fetchGitDirectory(parsed, sha, subpath, token) {
+  const path = parsed.path ? `${parsed.path}/${subpath}` : subpath;
+  const url = `${GITHUB_API}/repos/${parsed.owner}/${parsed.repo}/contents/${path}?ref=${sha}`;
+  const res = await fetch(url, { headers: githubHeaders(token) });
+  if (!res.ok)
+    return [];
+  return await res.json();
+}
+async function fetchGitFile(downloadUrl, token) {
+  const headers = { "User-Agent": "agentpacks" };
+  if (token)
+    headers.Authorization = `token ${token}`;
+  const res = await fetch(downloadUrl, { headers });
+  if (!res.ok) {
+    throw new Error(`Failed to fetch ${downloadUrl}: ${res.status}`);
+  }
+  return res.text();
+}
+async function fetchAndWriteSubdir(parsed, sha, remotePath, localDir, installed, token) {
+  mkdirSync(localDir, { recursive: true });
+  const entries = await fetchGitDirectory(parsed, sha, remotePath, token);
+  for (const entry of entries) {
+    if (entry.type === "file" && entry.download_url) {
+      const content = await fetchGitFile(entry.download_url, token);
+      const filepath = join(localDir, entry.name);
+      writeFileSync2(filepath, content);
+      installed.push(filepath);
+    } else if (entry.type === "dir") {
+      await fetchAndWriteSubdir(parsed, sha, `${remotePath}/${entry.name}`, join(localDir, entry.name), installed, token);
+    }
+  }
+}
+async function installGitSource(projectRoot, source, lockfile, options = {}) {
+  const parsed = parseGitSourceRef(source);
+  const sourceKey = gitSourceKey(parsed);
+  const installed = [];
+  const warnings = [];
+  let resolvedSha;
+  const locked = getLockedSource(lockfile, sourceKey);
+  if (options.frozen && !locked) {
+    throw new Error(`Frozen mode: no lockfile entry for source "${sourceKey}".`);
+  }
+  if (locked && !options.update) {
+    resolvedSha = locked.resolvedRef;
+  } else {
+    resolvedSha = await resolveGitRef(parsed, options.token);
+  }
+  const basePath = parsed.path || "packs";
+  const entries = await fetchGitDirectory(parsed, resolvedSha, basePath, options.token);
+  const curatedDir = resolve4(projectRoot, ".agentpacks", ".curated");
+  mkdirSync(curatedDir, { recursive: true });
+  const newLockEntry = {
+    requestedRef: parsed.ref,
+    resolvedRef: resolvedSha,
+    resolvedAt: new Date().toISOString(),
+    skills: {},
+    packs: {}
+  };
+  const packDirs = entries.filter((e) => e.type === "dir");
+  for (const packEntry of packDirs) {
+    const packName = packEntry.name;
+    const packOutDir = resolve4(curatedDir, packName);
+    const packFiles = await fetchGitDirectory(parsed, resolvedSha, `${basePath}/${packName}`, options.token);
+    mkdirSync(packOutDir, { recursive: true });
+    for (const file of packFiles) {
+      if (file.type === "file" && file.download_url) {
+        const content = await fetchGitFile(file.download_url, options.token);
+        writeFileSync2(join(packOutDir, file.name), content);
+        installed.push(join(packOutDir, file.name));
+        if (newLockEntry.packs) {
+          newLockEntry.packs[packName] = {
+            integrity: computeIntegrity(content)
+          };
+        }
+      } else if (file.type === "dir") {
+        await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${packName}/${file.name}`, join(packOutDir, file.name), installed, options.token);
+      }
+    }
+  }
+  if (packDirs.length === 0) {
+    const fileEntries = entries.filter((e) => e.type === "file");
+    if (fileEntries.length > 0) {
+      const packName = parsed.path.split("/").pop() ?? parsed.repo;
+      const packOutDir = resolve4(curatedDir, packName);
+      mkdirSync(packOutDir, { recursive: true });
+      for (const file of entries) {
+        if (file.type === "file" && file.download_url) {
+          const content = await fetchGitFile(file.download_url, options.token);
+          writeFileSync2(join(packOutDir, file.name), content);
+          installed.push(join(packOutDir, file.name));
+        } else if (file.type === "dir") {
+          await fetchAndWriteSubdir(parsed, resolvedSha, `${basePath}/${file.name}`, join(packOutDir, file.name), installed, options.token);
+        }
+      }
+    }
+  }
+  setLockedSource(lockfile, sourceKey, newLockEntry);
+  return { installed, warnings };
+}
+
+// src/sources/npm.ts
+import { mkdirSync as mkdirSync2, existsSync as existsSync4 } from "fs";
+import { resolve as resolve5, join as join2 } from "path";
+import { execSync } from "child_process";
+var NPM_REGISTRY = "https://registry.npmjs.org";
+async function resolveNpmVersion(parsed) {
+  const url = `${NPM_REGISTRY}/${encodeURIComponent(parsed.packageName)}/${parsed.version}`;
+  const res = await fetch(url, {
+    headers: { Accept: "application/json" }
+  });
+  if (!res.ok) {
+    throw new Error(`Could not resolve npm package "${parsed.packageName}@${parsed.version}": ${res.status}`);
+  }
+  const data = await res.json();
+  return { version: data.version, tarball: data.dist.tarball };
+}
+async function installNpmSource(projectRoot, source, lockfile, options = {}) {
+  const parsed = parseNpmSourceRef(source);
+  const sourceKey = npmSourceKey(parsed);
+  const installed = [];
+  const warnings = [];
+  const locked = getLockedSource(lockfile, sourceKey);
+  if (options.frozen && !locked) {
+    throw new Error(`Frozen mode: no lockfile entry for source "${sourceKey}".`);
+  }
+  let resolvedVersion;
+  let tarballUrl;
+  if (locked && !options.update) {
+    resolvedVersion = locked.resolvedRef;
+    tarballUrl = "";
+  } else {
+    const resolved = await resolveNpmVersion(parsed);
+    resolvedVersion = resolved.version;
+    tarballUrl = resolved.tarball;
+  }
+  const curatedDir = resolve5(projectRoot, ".agentpacks", ".curated");
+  mkdirSync2(curatedDir, { recursive: true });
+  const packDir = extractNpmPack(parsed, resolvedVersion, curatedDir, installed, warnings);
+  const newEntry = {
+    requestedRef: parsed.version,
+    resolvedRef: resolvedVersion,
+    resolvedAt: new Date().toISOString(),
+    skills: {},
+    packs: {}
+  };
+  setLockedSource(lockfile, sourceKey, newEntry);
+  return { installed, warnings };
+}
+function extractNpmPack(parsed, version, curatedDir, installed, warnings) {
+  const pkgSpec = `${parsed.packageName}@${version}`;
+  const packName = parsed.packageName.replace(/^@/, "").replace(/\//g, "-");
+  const packOutDir = resolve5(curatedDir, packName);
+  try {
+    const tmpDir = resolve5(curatedDir, ".tmp-npm");
+    mkdirSync2(tmpDir, { recursive: true });
+    execSync(`npm pack ${pkgSpec} --pack-destination "${tmpDir}"`, {
+      stdio: "pipe",
+      timeout: 30000
+    });
+    const tgzFiles = __require("fs").readdirSync(tmpDir).filter((f) => f.endsWith(".tgz"));
+    if (tgzFiles.length === 0) {
+      warnings.push(`No tarball found for ${pkgSpec}`);
+      return packOutDir;
+    }
+    const tgzPath = join2(tmpDir, tgzFiles[0]);
+    mkdirSync2(packOutDir, { recursive: true });
+    execSync(`tar xzf "${tgzPath}" -C "${packOutDir}" --strip-components=1`, {
+      stdio: "pipe",
+      timeout: 15000
+    });
+    execSync(`rm -rf "${tmpDir}"`, { stdio: "pipe" });
+    const subpath = parsed.path || "";
+    const targetDir = subpath ? join2(packOutDir, subpath) : packOutDir;
+    if (existsSync4(targetDir)) {
+      collectFiles(targetDir, installed);
+    }
+  } catch (err) {
+    warnings.push(`Failed to extract npm pack ${pkgSpec}: ${err instanceof Error ? err.message : String(err)}`);
+  }
+  return packOutDir;
+}
+function collectFiles(dir, out) {
+  const fs = __require("fs");
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join2(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+}
+
+// src/cli/install.ts
+init_config();
+import chalk from "chalk";
+async function runInstall(projectRoot, options) {
+  const config = loadWorkspaceConfig(projectRoot);
+  const lockfile = loadLockfile(projectRoot);
+  const verbose = options.verbose ?? config.verbose;
+  const remotePacks = config.packs.filter((ref) => isGitPackRef(ref) || isNpmPackRef(ref));
+  const localPacks = config.packs.filter((ref) => isLocalPackRef(ref));
+  if (remotePacks.length === 0) {
+    console.log(chalk.dim("No remote packs to install. All packs are local."));
+    return;
+  }
+  if (verbose) {
+    console.log(chalk.dim(`Found ${remotePacks.length} remote pack(s) to install`));
+    console.log(chalk.dim(`  (${localPacks.length} local pack(s) skipped)`));
+  }
+  if (options.frozen) {
+    const sourceKeys = remotePacks.map((ref) => ref);
+    const frozenCheck = isLockfileFrozenValid(lockfile, sourceKeys);
+    if (!frozenCheck.valid) {
+      console.log(chalk.red(`Frozen install failed. Missing lockfile entries: ${frozenCheck.missing.join(", ")}`));
+      process.exit(1);
+    }
+  }
+  let totalInstalled = 0;
+  const allWarnings = [];
+  for (const packRef of remotePacks) {
+    if (verbose) {
+      console.log(chalk.dim(`  Installing ${packRef}...`));
+    }
+    try {
+      let result;
+      if (isGitPackRef(packRef)) {
+        const token = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN ?? undefined;
+        result = await installGitSource(projectRoot, packRef, lockfile, {
+          update: options.update,
+          frozen: options.frozen,
+          token
+        });
+      } else if (isNpmPackRef(packRef)) {
+        result = await installNpmSource(projectRoot, packRef, lockfile, {
+          update: options.update,
+          frozen: options.frozen
+        });
+      } else {
+        continue;
+      }
+      totalInstalled += result.installed.length;
+      allWarnings.push(...result.warnings);
+      if (verbose && result.installed.length > 0) {
+        console.log(chalk.dim(`    ${result.installed.length} file(s) installed`));
+      }
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      console.log(chalk.red(`  error [${packRef}]: ${msg}`));
+      allWarnings.push(`Failed to install ${packRef}: ${msg}`);
+    }
+  }
+  for (const w of allWarnings) {
+    console.log(chalk.yellow(`  warn: ${w}`));
+  }
+  saveLockfile(projectRoot, lockfile);
+  console.log(chalk.green(`Installed ${totalInstalled} file(s) from ${remotePacks.length} source(s)`));
+  if (verbose) {
+    console.log(chalk.dim("Lockfile updated: agentpacks.lock"));
+  }
+}
+export {
+  runInstall
+};

package/dist/cli/pack/create.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Create a new pack scaffold.
+ */
+export declare function runPackCreate(projectRoot: string, name: string): void;