agentpacks 0.2.0

package/dist/node/utils/diff.js

@@ -0,0 +1,144 @@
+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/diff.ts
+import { existsSync, readFileSync } from "fs";
+function diffFile(filepath, newContent) {
+  if (!existsSync(filepath)) {
+    return {
+      filepath,
+      status: "added",
+      diffLines: formatAddedDiff(filepath, newContent)
+    };
+  }
+  const existing = readFileSync(filepath, "utf-8");
+  if (existing === newContent) {
+    return { filepath, status: "unchanged", diffLines: [] };
+  }
+  return {
+    filepath,
+    status: "modified",
+    diffLines: computeUnifiedDiff(filepath, existing, newContent)
+  };
+}
+function formatAddedDiff(filepath, content) {
+  const lines = [
+    `--- /dev/null`,
+    `+++ ${filepath}`,
+    `@@ -0,0 +1,${content.split(`
+`).length} @@`
+  ];
+  for (const line of content.split(`
+`)) {
+    lines.push(`+${line}`);
+  }
+  return lines;
+}
+function computeUnifiedDiff(filepath, oldContent, newContent) {
+  const oldLines = oldContent.split(`
+`);
+  const newLines = newContent.split(`
+`);
+  const result = [`--- ${filepath}`, `+++ ${filepath}`];
+  const hunks = findHunks(oldLines, newLines);
+  for (const hunk of hunks) {
+    result.push(`@@ -${hunk.oldStart + 1},${hunk.oldCount} +${hunk.newStart + 1},${hunk.newCount} @@`);
+    for (const line of hunk.lines) {
+      result.push(line);
+    }
+  }
+  return result;
+}
+function findHunks(oldLines, newLines) {
+  const CONTEXT = 3;
+  const changes = [];
+  let oi = 0;
+  let ni = 0;
+  while (oi < oldLines.length || ni < newLines.length) {
+    if (oi < oldLines.length && ni < newLines.length && oldLines[oi] === newLines[ni]) {
+      changes.push({ type: " ", line: oldLines[oi], oldIdx: oi, newIdx: ni });
+      oi++;
+      ni++;
+    } else if (ni < newLines.length && (oi >= oldLines.length || !newLines.slice(ni).includes(oldLines[oi]))) {
+      changes.push({ type: "+", line: newLines[ni], oldIdx: oi, newIdx: ni });
+      ni++;
+    } else {
+      changes.push({ type: "-", line: oldLines[oi], oldIdx: oi, newIdx: oi });
+      oi++;
+    }
+  }
+  const hunks = [];
+  let currentHunk = null;
+  let unchangedCount = 0;
+  for (const change of changes) {
+    if (change.type === " ") {
+      unchangedCount++;
+      if (currentHunk && unchangedCount <= CONTEXT) {
+        currentHunk.lines.push(` ${change.line}`);
+        currentHunk.oldCount++;
+        currentHunk.newCount++;
+      } else if (currentHunk && unchangedCount > CONTEXT * 2) {
+        hunks.push(currentHunk);
+        currentHunk = null;
+      }
+    } else {
+      if (!currentHunk) {
+        const contextStart = Math.max(0, changes.indexOf(change) - CONTEXT);
+        currentHunk = {
+          oldStart: change.oldIdx - Math.min(CONTEXT, changes.indexOf(change) - contextStart),
+          oldCount: 0,
+          newStart: change.newIdx - Math.min(CONTEXT, changes.indexOf(change) - contextStart),
+          newCount: 0,
+          lines: []
+        };
+        for (let i = contextStart;i < changes.indexOf(change); i++) {
+          if (changes[i].type === " ") {
+            currentHunk.lines.push(` ${changes[i].line}`);
+            currentHunk.oldCount++;
+            currentHunk.newCount++;
+          }
+        }
+      }
+      unchangedCount = 0;
+      currentHunk.lines.push(`${change.type}${change.line}`);
+      if (change.type === "-")
+        currentHunk.oldCount++;
+      if (change.type === "+")
+        currentHunk.newCount++;
+    }
+  }
+  if (currentHunk)
+    hunks.push(currentHunk);
+  return hunks;
+}
+export {
+  diffFile
+};

package/dist/node/utils/filesystem.js

@@ -0,0 +1,152 @@
+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;
+  }
+}
+export {
+  writeGeneratedJson,
+  writeGeneratedFile,
+  removeIfExists,
+  relPath,
+  readJsonOrNull,
+  readFileOrNull,
+  listFiles,
+  listDirs,
+  isGeneratedFile,
+  ensureDir
+};

package/dist/node/utils/frontmatter.js

@@ -0,0 +1,52 @@
+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/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);
+}
+export {
+  serializeFrontmatter,
+  parseFrontmatter
+};

package/dist/node/utils/global.js

@@ -0,0 +1,81 @@
+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/global.ts
+import { homedir } from "os";
+import { join, resolve } from "path";
+import { existsSync } from "fs";
+function globalConfigDir() {
+  return resolve(process.env.AGENTPACKS_GLOBAL_DIR ?? join(homedir(), ".agentpacks"));
+}
+function globalConfigFile() {
+  return join(globalConfigDir(), "agentpacks.jsonc");
+}
+function hasGlobalConfig() {
+  return existsSync(globalConfigFile());
+}
+function globalTargetDir(targetId, platform = process.platform) {
+  const home = homedir();
+  switch (targetId) {
+    case "opencode":
+      return join(xdgConfig(platform, home), "opencode");
+    case "cursor":
+      return join(home, ".cursor");
+    case "claudecode":
+      return join(home, ".claude");
+    case "codexcli":
+      return join(xdgConfig(platform, home), "codex");
+    case "geminicli":
+      return join(xdgConfig(platform, home), "gemini");
+    case "copilot":
+      return join(xdgConfig(platform, home), "github-copilot");
+    default:
+      return join(xdgConfig(platform, home), targetId);
+  }
+}
+function xdgConfig(platform, home) {
+  if (process.env.XDG_CONFIG_HOME) {
+    return process.env.XDG_CONFIG_HOME;
+  }
+  if (platform === "darwin") {
+    return join(home, "Library", "Application Support");
+  }
+  if (platform === "win32") {
+    return process.env.APPDATA ?? join(home, "AppData", "Roaming");
+  }
+  return join(home, ".config");
+}
+export {
+  hasGlobalConfig,
+  globalTargetDir,
+  globalConfigFile,
+  globalConfigDir
+};

package/dist/node/utils/markdown.js

@@ -0,0 +1,62 @@
+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/markdown.ts
+function stripGeneratedHeader(content) {
+  return content.replace(/^<!-- Generated by agentpacks.*-->\n/, "").replace(/^\/\/ Generated by agentpacks.*\n/, "");
+}
+function packNameToIdentifier(packName) {
+  return packName.split(/[-_.]/).filter((part) => part.length > 0).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function extractFirstHeading(content) {
+  const match = content.match(/^#{1,6}\s+(.+)$/m);
+  return match?.[1]?.trim() ?? null;
+}
+function combineMarkdown(sections, separator = `
+
+---
+
+`) {
+  return sections.filter(Boolean).join(separator);
+}
+function wrapSection(heading, content, level = 2) {
+  const prefix = "#".repeat(level);
+  return `${prefix} ${heading}
+
+${content}`;
+}
+export {
+  wrapSection,
+  stripGeneratedHeader,
+  packNameToIdentifier,
+  extractFirstHeading,
+  combineMarkdown
+};

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

@@ -0,0 +1,27 @@
+/**
+ * Git source reference types and pure parsing utilities.
+ * No I/O or network calls — pure functions only.
+ */
+/**
+ * Parsed git source reference.
+ * Format: owner/repo, owner/repo@ref, owner/repo@ref:path
+ * Or: github:owner/repo[@ref][:path]
+ */
+export interface GitSourceRef {
+    owner: string;
+    repo: string;
+    ref: string;
+    path: string;
+}
+/**
+ * Parse a git source reference string.
+ */
+export declare function parseGitSourceRef(source: string): GitSourceRef;
+/**
+ * Check if a pack reference is a git source.
+ */
+export declare function isGitPackRef(packRef: string): boolean;
+/**
+ * Build a canonical source key for lockfile entries.
+ */
+export declare function gitSourceKey(parsed: GitSourceRef): string;

package/dist/sources/git-ref.js

@@ -0,0 +1,79 @@
+// @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/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}`;
+}
+export {
+  parseGitSourceRef,
+  isGitPackRef,
+  gitSourceKey
+};

package/dist/sources/git.d.ts

@@ -0,0 +1,29 @@
+import { type Lockfile } from '../core/lockfile.js';
+import { type GitSourceRef } from './git-ref.js';
+/**
+ * Resolve git ref to a commit SHA using GitHub API.
+ */
+export declare function resolveGitRef(parsed: GitSourceRef, token?: string): Promise<string>;
+/**
+ * Fetch a directory listing from GitHub Contents API.
+ */
+export declare function fetchGitDirectory(parsed: GitSourceRef, sha: string, subpath: string, token?: string): Promise<Array<{
+    name: string;
+    type: string;
+    download_url: string | null;
+}>>;
+/**
+ * Fetch a single file content from a GitHub download URL.
+ */
+export declare function fetchGitFile(downloadUrl: string, token?: string): Promise<string>;
+/**
+ * Install a git-based pack source into .agentpacks/.curated/.
+ */
+export declare function installGitSource(projectRoot: string, source: string, lockfile: Lockfile, options?: {
+    update?: boolean;
+    frozen?: boolean;
+    token?: string;
+}): Promise<{
+    installed: string[];
+    warnings: string[];
+}>;