agentpacks 0.2.0

package/dist/node/sources/npm.js

@@ -0,0 +1,211 @@
+import { createRequire } from "node:module";
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// 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/node/targets/additional-targets.js

@@ -0,0 +1,428 @@
+import { createRequire } from "node:module";
+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 = /* @__PURE__ */ createRequire(import.meta.url);
+
+// src/utils/filesystem.ts
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  writeFileSync,
+  readdirSync,
+  statSync
+} from "fs";
+import { dirname, relative, join } from "path";
+import { removeSync } from "fs-extra";
+var GENERATED_HEADER_MD = "<!-- Generated by agentpacks. DO NOT EDIT. -->";
+var GENERATED_HEADER_JSON = "// Generated by agentpacks. DO NOT EDIT.";
+var GENERATED_HEADER_JS = "// Generated by agentpacks. DO NOT EDIT.";
+function writeGeneratedFile(filepath, content, options = {}) {
+  const { header = true, type } = options;
+  const ext = type ?? inferFileType(filepath);
+  ensureDir(dirname(filepath));
+  let output = content;
+  if (header) {
+    const headerComment = getHeader(ext);
+    if (headerComment) {
+      output = `${headerComment}
+${content}`;
+    }
+  }
+  writeFileSync(filepath, output, "utf-8");
+}
+function writeGeneratedJson(filepath, data, options = {}) {
+  const json = JSON.stringify(data, null, 2);
+  writeGeneratedFile(filepath, json + `
+`, { ...options, type: "json" });
+}
+function readFileOrNull(filepath) {
+  if (!existsSync(filepath))
+    return null;
+  return readFileSync(filepath, "utf-8");
+}
+function readJsonOrNull(filepath) {
+  const content = readFileOrNull(filepath);
+  if (content === null)
+    return null;
+  return JSON.parse(content);
+}
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function removeIfExists(targetPath) {
+  if (existsSync(targetPath)) {
+    removeSync(targetPath);
+  }
+}
+function listFiles(dirPath, options = {}) {
+  const { extension, recursive = false } = options;
+  if (!existsSync(dirPath))
+    return [];
+  const results = [];
+  const entries = readdirSync(dirPath);
+  for (const entry of entries) {
+    const fullPath = join(dirPath, entry);
+    const stat = statSync(fullPath);
+    if (stat.isDirectory() && recursive) {
+      results.push(...listFiles(fullPath, options));
+    } else if (stat.isFile()) {
+      if (!extension || entry.endsWith(extension)) {
+        results.push(fullPath);
+      }
+    }
+  }
+  return results;
+}
+function listDirs(dirPath) {
+  if (!existsSync(dirPath))
+    return [];
+  return readdirSync(dirPath).map((entry) => join(dirPath, entry)).filter((fullPath) => statSync(fullPath).isDirectory());
+}
+function relPath(projectRoot, filepath) {
+  return relative(projectRoot, filepath);
+}
+function isGeneratedFile(filepath) {
+  const content = readFileOrNull(filepath);
+  if (!content)
+    return false;
+  return content.startsWith(GENERATED_HEADER_MD) || content.startsWith(GENERATED_HEADER_JSON) || content.startsWith(GENERATED_HEADER_JS);
+}
+function inferFileType(filepath) {
+  if (filepath.endsWith(".json") || filepath.endsWith(".jsonc"))
+    return "json";
+  if (filepath.endsWith(".ts") || filepath.endsWith(".mts"))
+    return "ts";
+  if (filepath.endsWith(".js") || filepath.endsWith(".mjs"))
+    return "js";
+  return "md";
+}
+function getHeader(type) {
+  switch (type) {
+    case "md":
+      return GENERATED_HEADER_MD;
+    case "json":
+      return GENERATED_HEADER_JSON;
+    case "js":
+    case "ts":
+      return GENERATED_HEADER_JS;
+    default:
+      return null;
+  }
+}
+
+// src/utils/frontmatter.ts
+import matter from "gray-matter";
+function parseFrontmatter(source) {
+  const { data, content } = matter(source);
+  return {
+    data,
+    content: content.trim(),
+    raw: source
+  };
+}
+function serializeFrontmatter(data, content) {
+  const filtered = Object.fromEntries(Object.entries(data).filter(([, v]) => v !== undefined));
+  if (Object.keys(filtered).length === 0) {
+    return content;
+  }
+  return matter.stringify(content, filtered);
+}
+
+// src/features/rules.ts
+import { readFileSync as readFileSync2 } from "fs";
+import { basename } from "path";
+function parseRules(rulesDir, packName) {
+  const files = listFiles(rulesDir, { extension: ".md" });
+  return files.map((filepath) => parseRuleFile(filepath, packName));
+}
+function parseRuleFile(filepath, packName) {
+  const raw = readFileSync2(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: basename(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function ruleMatchesTarget(rule, targetId) {
+  const { targets } = rule.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+function getRootRules(rules) {
+  return rules.filter((r) => r.meta.root === true);
+}
+function getDetailRules(rules) {
+  return rules.filter((r) => r.meta.root !== true);
+}
+
+// src/features/commands.ts
+import { readFileSync as readFileSync3 } from "fs";
+import { basename as basename2 } from "path";
+function parseCommands(commandsDir, packName) {
+  const files = listFiles(commandsDir, { extension: ".md" });
+  return files.map((filepath) => parseCommandFile(filepath, packName));
+}
+function parseCommandFile(filepath, packName) {
+  const raw = readFileSync3(filepath, "utf-8");
+  const { data, content } = parseFrontmatter(raw);
+  return {
+    name: basename2(filepath, ".md"),
+    sourcePath: filepath,
+    packName,
+    meta: data,
+    content
+  };
+}
+function commandMatchesTarget(cmd, targetId) {
+  const { targets } = cmd.meta;
+  if (!targets || targets === "*")
+    return true;
+  if (Array.isArray(targets) && targets.includes("*"))
+    return true;
+  return Array.isArray(targets) && targets.includes(targetId);
+}
+
+// src/targets/base-target.ts
+class BaseTarget {
+  supportsFeature(feature) {
+    return this.supportedFeatures.includes(feature);
+  }
+  getEffectiveFeatures(enabledFeatures) {
+    return enabledFeatures.filter((f) => this.supportsFeature(f));
+  }
+  createResult(filesWritten = [], filesDeleted = [], warnings = []) {
+    return {
+      targetId: this.id,
+      filesWritten,
+      filesDeleted,
+      warnings
+    };
+  }
+}
+
+// src/targets/generic-md-target.ts
+import { resolve as resolve2, join as join2 } from "path";
+function createGenericMdTarget(config) {
+  return new GenericMdTarget(config);
+}
+
+class GenericMdTarget extends BaseTarget {
+  id;
+  name;
+  supportedFeatures;
+  config;
+  constructor(config) {
+    super();
+    this.id = config.id;
+    this.name = config.name;
+    this.supportedFeatures = config.supportedFeatures;
+    this.config = config;
+  }
+  generate(options) {
+    const { projectRoot, baseDir, features, enabledFeatures, deleteExisting } = options;
+    const root = resolve2(projectRoot, baseDir);
+    const effective = this.getEffectiveFeatures(enabledFeatures);
+    const filesWritten = [];
+    const filesDeleted = [];
+    const warnings = [];
+    const configDir = resolve2(root, this.config.configDir);
+    const rulesSubDir = this.config.rulesDir ?? "rules";
+    const ext = this.config.ruleExtension ?? ".md";
+    if (effective.includes("rules")) {
+      const rulesDir = resolve2(configDir, rulesSubDir);
+      if (deleteExisting) {
+        removeIfExists(rulesDir);
+        filesDeleted.push(rulesDir);
+      }
+      ensureDir(rulesDir);
+      const rules = features.rules.filter((r) => ruleMatchesTarget(r, this.id));
+      for (const rule of rules) {
+        const filepath = join2(rulesDir, `${rule.name}${ext}`);
+        writeGeneratedFile(filepath, rule.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("commands")) {
+      const commandsDir = resolve2(configDir, "commands");
+      if (deleteExisting) {
+        removeIfExists(commandsDir);
+        filesDeleted.push(commandsDir);
+      }
+      ensureDir(commandsDir);
+      const commands = features.commands.filter((c) => commandMatchesTarget(c, this.id));
+      for (const cmd of commands) {
+        const filepath = join2(commandsDir, `${cmd.name}.md`);
+        writeGeneratedFile(filepath, cmd.content);
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("mcp")) {
+      const mcpEntries = Object.entries(features.mcpServers);
+      if (mcpEntries.length > 0) {
+        const mcpDir = this.config.mcpInConfigDir ? configDir : root;
+        const filepath = resolve2(mcpDir, "mcp.json");
+        writeGeneratedJson(filepath, { mcpServers: features.mcpServers }, {
+          header: false
+        });
+        filesWritten.push(filepath);
+      }
+    }
+    if (effective.includes("ignore") && this.config.ignoreFile) {
+      if (features.ignorePatterns.length > 0) {
+        const filepath = resolve2(root, this.config.ignoreFile);
+        writeGeneratedFile(filepath, features.ignorePatterns.join(`
+`) + `
+`);
+        filesWritten.push(filepath);
+      }
+    }
+    return this.createResult(filesWritten, filesDeleted, warnings);
+  }
+}
+
+// src/targets/additional-targets.ts
+var ClineTarget = createGenericMdTarget({
+  id: "cline",
+  name: "Cline",
+  configDir: ".cline",
+  supportedFeatures: ["rules", "commands", "mcp", "ignore"],
+  ignoreFile: ".clineignore",
+  mcpInConfigDir: true
+});
+var KiloTarget = createGenericMdTarget({
+  id: "kilo",
+  name: "Kilo Code",
+  configDir: ".kilo",
+  supportedFeatures: ["rules", "commands", "mcp", "ignore"],
+  ignoreFile: ".kiloignore",
+  mcpInConfigDir: true
+});
+var RooTarget = createGenericMdTarget({
+  id: "roo",
+  name: "Roo Code",
+  configDir: ".roo",
+  supportedFeatures: ["rules", "commands", "mcp", "ignore"],
+  ignoreFile: ".rooignore",
+  mcpInConfigDir: true
+});
+var QwenCodeTarget = createGenericMdTarget({
+  id: "qwencode",
+  name: "Qwen Code",
+  configDir: ".qwencode",
+  supportedFeatures: ["rules", "mcp", "ignore"],
+  ignoreFile: ".qwencodeignore",
+  mcpInConfigDir: true
+});
+var KiroTarget = createGenericMdTarget({
+  id: "kiro",
+  name: "Kiro",
+  configDir: ".kiro",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var FactoryDroidTarget = createGenericMdTarget({
+  id: "factorydroid",
+  name: "Factory Droid",
+  configDir: ".factorydroid",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var AntiGravityTarget = createGenericMdTarget({
+  id: "antigravity",
+  name: "AntiGravity",
+  configDir: ".antigravity",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var JunieTarget = createGenericMdTarget({
+  id: "junie",
+  name: "Junie",
+  configDir: ".junie",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var AugmentCodeTarget = createGenericMdTarget({
+  id: "augmentcode",
+  name: "Augment Code",
+  configDir: ".augmentcode",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var WindsurfTarget = createGenericMdTarget({
+  id: "windsurf",
+  name: "Windsurf",
+  configDir: ".windsurf",
+  supportedFeatures: ["rules", "mcp", "ignore"],
+  ignoreFile: ".windsurfignore",
+  mcpInConfigDir: true
+});
+var WarpTarget = createGenericMdTarget({
+  id: "warp",
+  name: "Warp",
+  configDir: ".warp",
+  supportedFeatures: ["rules"]
+});
+var ReplitTarget = createGenericMdTarget({
+  id: "replit",
+  name: "Replit Agent",
+  configDir: ".replit",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+var ZedTarget = createGenericMdTarget({
+  id: "zed",
+  name: "Zed",
+  configDir: ".zed",
+  supportedFeatures: ["rules", "mcp"],
+  mcpInConfigDir: true
+});
+export {
+  ZedTarget,
+  WindsurfTarget,
+  WarpTarget,
+  RooTarget,
+  ReplitTarget,
+  QwenCodeTarget,
+  KiroTarget,
+  KiloTarget,
+  JunieTarget,
+  FactoryDroidTarget,
+  ClineTarget,
+  AugmentCodeTarget,
+  AntiGravityTarget
+};