agentpacks 0.2.0

package/dist/sources/local.js

@@ -0,0 +1,52 @@
+// @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/sources/local.ts
+import { existsSync } from "fs";
+import { resolve, isAbsolute } from "path";
+function resolveLocalPack(packRef, projectRoot) {
+  let resolved;
+  if (isAbsolute(packRef)) {
+    resolved = packRef;
+  } else {
+    resolved = resolve(projectRoot, packRef);
+  }
+  if (!existsSync(resolved))
+    return null;
+  return resolved;
+}
+function isLocalPackRef(packRef) {
+  return packRef.startsWith("./") || packRef.startsWith("../") || isAbsolute(packRef);
+}
+export {
+  resolveLocalPack,
+  isLocalPackRef
+};

package/dist/sources/npm-ref.d.ts

@@ -0,0 +1,30 @@
+/**
+ * npm pack source — reference parsing and detection utilities.
+ * Pure functions, no I/O.
+ */
+/**
+ * Parsed npm source reference.
+ * Formats:
+ *   npm:package-name[@version][:path]
+ *   @scope/package-name[@version][:path]
+ */
+export interface NpmSourceRef {
+    /** Full package name (e.g. "@acme/agent-rules" or "my-rules") */
+    packageName: string;
+    /** Requested version/tag (default: "latest") */
+    version: string;
+    /** Optional subpath within the package (e.g. "packs/security") */
+    path: string;
+}
+/**
+ * Parse an npm source reference string.
+ */
+export declare function parseNpmSourceRef(source: string): NpmSourceRef;
+/**
+ * Check if a pack reference is an npm source.
+ */
+export declare function isNpmPackRef(packRef: string): boolean;
+/**
+ * Build a canonical source key for lockfile entries.
+ */
+export declare function npmSourceKey(parsed: NpmSourceRef): string;

package/dist/sources/npm-ref.js

@@ -0,0 +1,84 @@
+// @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/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}`;
+}
+export {
+  parseNpmSourceRef,
+  npmSourceKey,
+  isNpmPackRef
+};

package/dist/sources/npm.d.ts

@@ -0,0 +1,20 @@
+import { type Lockfile } from '../core/lockfile.js';
+import { type NpmSourceRef } from './npm-ref.js';
+/**
+ * Resolve an npm package version to exact version + tarball URL.
+ */
+export declare function resolveNpmVersion(parsed: NpmSourceRef): Promise<{
+    version: string;
+    tarball: string;
+}>;
+/**
+ * Install an npm-based pack source using `npm pack` + tar extraction.
+ * Falls back to tarball download if npm CLI is unavailable.
+ */
+export declare function installNpmSource(projectRoot: string, source: string, lockfile: Lockfile, options?: {
+    update?: boolean;
+    frozen?: boolean;
+}): Promise<{
+    installed: string[];
+    warnings: string[];
+}>;

package/dist/sources/npm.js

@@ -0,0 +1,211 @@
+// @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/lockfile.ts
+import { existsSync, readFileSync, writeFileSync } from "fs";
+import { resolve } from "path";
+import { createHash } from "crypto";
+var LOCKFILE_VERSION = 1;
+var LOCKFILE_NAME = "agentpacks.lock";
+function loadLockfile(projectRoot) {
+  const filepath = resolve(projectRoot, LOCKFILE_NAME);
+  if (!existsSync(filepath)) {
+    return { lockfileVersion: LOCKFILE_VERSION, sources: {} };
+  }
+  const raw = readFileSync(filepath, "utf-8");
+  return JSON.parse(raw);
+}
+function saveLockfile(projectRoot, lockfile) {
+  const filepath = resolve(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/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/npm.ts
+import { mkdirSync, existsSync as existsSync2 } from "fs";
+import { resolve as resolve2, join } 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 = resolve2(projectRoot, ".agentpacks", ".curated");
+  mkdirSync(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 = resolve2(curatedDir, packName);
+  try {
+    const tmpDir = resolve2(curatedDir, ".tmp-npm");
+    mkdirSync(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 = join(tmpDir, tgzFiles[0]);
+    mkdirSync(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 ? join(packOutDir, subpath) : packOutDir;
+    if (existsSync2(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 = join(dir, entry.name);
+    if (entry.isDirectory()) {
+      collectFiles(full, out);
+    } else {
+      out.push(full);
+    }
+  }
+}
+export {
+  resolveNpmVersion,
+  installNpmSource
+};

package/dist/targets/additional-targets.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Cline — VS Code AI extension.
+ * Config: .cline/rules/*.md, .cline/mcp.json
+ */
+export declare const ClineTarget: import("./base-target.js").BaseTarget;
+/**
+ * Kilo Code — AI coding assistant (Cline fork).
+ * Config: .kilo/rules/*.md
+ */
+export declare const KiloTarget: import("./base-target.js").BaseTarget;
+/**
+ * Roo Code — AI coding assistant (Cline fork).
+ * Config: .roo/rules/*.md
+ */
+export declare const RooTarget: import("./base-target.js").BaseTarget;
+/**
+ * Qwen Code — Alibaba's AI coding assistant.
+ * Config: .qwencode/rules/*.md
+ */
+export declare const QwenCodeTarget: import("./base-target.js").BaseTarget;
+/**
+ * Kiro — AWS AI coding assistant.
+ * Config: .kiro/rules/*.md
+ */
+export declare const KiroTarget: import("./base-target.js").BaseTarget;
+/**
+ * Factory Droid — AI coding assistant.
+ * Config: .factorydroid/rules/*.md
+ */
+export declare const FactoryDroidTarget: import("./base-target.js").BaseTarget;
+/**
+ * AntiGravity — AI coding assistant.
+ * Config: .antigravity/rules/*.md
+ */
+export declare const AntiGravityTarget: import("./base-target.js").BaseTarget;
+/**
+ * JetBrains Junie — AI coding assistant.
+ * Config: .junie/rules/*.md
+ */
+export declare const JunieTarget: import("./base-target.js").BaseTarget;
+/**
+ * Augment Code — AI coding assistant.
+ * Config: .augmentcode/rules/*.md
+ */
+export declare const AugmentCodeTarget: import("./base-target.js").BaseTarget;
+/**
+ * Windsurf — AI coding IDE.
+ * Config: .windsurf/rules/*.md, .windsurfrules
+ */
+export declare const WindsurfTarget: import("./base-target.js").BaseTarget;
+/**
+ * Warp — AI-native terminal.
+ * Config: .warp/rules/*.md
+ */
+export declare const WarpTarget: import("./base-target.js").BaseTarget;
+/**
+ * Replit Agent — cloud IDE AI.
+ * Config: .replit/rules/*.md
+ */
+export declare const ReplitTarget: import("./base-target.js").BaseTarget;
+/**
+ * Zed — high-performance editor with AI.
+ * Config: .zed/rules/*.md
+ */
+export declare const ZedTarget: import("./base-target.js").BaseTarget;