agentpacks 0.2.0

package/dist/cli/pack/validate.js

@@ -0,0 +1,364 @@
+// @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/utils/filesystem.ts
+import {
+  existsSync as existsSync2,
+  mkdirSync,
+  readFileSync as readFileSync2,
+  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 (!existsSync2(filepath))
+    return null;
+  return readFileSync2(filepath, "utf-8");
+}
+function readJsonOrNull(filepath) {
+  const content = readFileOrNull(filepath);
+  if (content === null)
+    return null;
+  return JSON.parse(content);
+}
+function ensureDir(dirPath) {
+  if (!existsSync2(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function removeIfExists(targetPath) {
+  if (existsSync2(targetPath)) {
+    removeSync(targetPath);
+  }
+}
+function listFiles(dirPath, options = {}) {
+  const { extension, recursive = false } = options;
+  if (!existsSync2(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 (!existsSync2(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/cli/pack/validate.ts
+init_config();
+import { existsSync as existsSync3 } from "fs";
+import { resolve as resolve3, join as join2 } from "path";
+import chalk from "chalk";
+function runPackValidate(projectRoot) {
+  const config = loadWorkspaceConfig(projectRoot);
+  let hasErrors = false;
+  for (const packRef of config.packs) {
+    const packDir = resolvePackDir(projectRoot, packRef);
+    console.log(chalk.bold(`
+Validating pack: ${packRef}`));
+    if (!packDir || !existsSync3(packDir)) {
+      console.log(chalk.red(`  ERROR: Pack directory not found: ${packRef}`));
+      hasErrors = true;
+      continue;
+    }
+    const packJsonPath = resolve3(packDir, "pack.json");
+    if (!existsSync3(packJsonPath)) {
+      console.log(chalk.yellow("  warn: No pack.json found. Name will be inferred from directory."));
+    } else {
+      try {
+        loadPackManifest(packDir);
+        console.log(chalk.green("  pack.json: valid"));
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        console.log(chalk.red(`  ERROR pack.json: ${message}`));
+        hasErrors = true;
+      }
+    }
+    const subdirs = ["rules", "commands", "agents", "skills"];
+    for (const sub of subdirs) {
+      const subDir = join2(packDir, sub);
+      if (existsSync3(subDir)) {
+        if (sub === "skills") {
+          const skillDirs = listDirs(subDir);
+          for (const skillDir of skillDirs) {
+            const skillMd = join2(skillDir, "SKILL.md");
+            if (!existsSync3(skillMd)) {
+              console.log(chalk.yellow(`  warn: skills/${skillDir.split("/").pop()} missing SKILL.md`));
+            }
+          }
+          console.log(chalk.green(`  ${sub}/: ${skillDirs.length} skill(s)`));
+        } else {
+          const files = listFiles(subDir, { extension: ".md" });
+          console.log(chalk.green(`  ${sub}/: ${files.length} file(s)`));
+        }
+      }
+    }
+    const optionalFiles = ["mcp.json", "ignore", ".aiignore"];
+    for (const file of optionalFiles) {
+      if (existsSync3(join2(packDir, file))) {
+        console.log(chalk.green(`  ${file}: present`));
+      }
+    }
+    const hooksJson = join2(packDir, "hooks", "hooks.json");
+    if (existsSync3(hooksJson)) {
+      console.log(chalk.green("  hooks/hooks.json: present"));
+    }
+    const pluginsDir = join2(packDir, "plugins");
+    if (existsSync3(pluginsDir)) {
+      const pluginFiles = [
+        ...listFiles(pluginsDir, { extension: ".ts" }),
+        ...listFiles(pluginsDir, { extension: ".js" })
+      ];
+      console.log(chalk.green(`  plugins/: ${pluginFiles.length} file(s)`));
+    }
+  }
+  console.log();
+  if (hasErrors) {
+    console.log(chalk.red("Validation failed with errors."));
+    process.exit(1);
+  } else {
+    console.log(chalk.green("All packs valid."));
+  }
+}
+function resolvePackDir(projectRoot, packRef) {
+  if (packRef.startsWith("./") || packRef.startsWith("../")) {
+    return resolve3(projectRoot, packRef);
+  }
+  return resolve3(projectRoot, packRef);
+}
+export {
+  runPackValidate
+};

package/dist/core/config.d.ts

@@ -0,0 +1,77 @@
+import { z } from 'zod';
+/**
+ * All supported target identifiers.
+ */
+export declare const TARGET_IDS: readonly ["opencode", "cursor", "claudecode", "codexcli", "geminicli", "copilot", "agentsmd", "cline", "kilo", "roo", "qwencode", "kiro", "factorydroid", "antigravity", "junie", "augmentcode", "windsurf", "warp", "replit", "zed"];
+export type TargetId = (typeof TARGET_IDS)[number];
+/**
+ * All supported feature types.
+ */
+export declare const FEATURE_IDS: readonly ["rules", "commands", "agents", "skills", "hooks", "plugins", "mcp", "ignore"];
+export type FeatureId = (typeof FEATURE_IDS)[number];
+/**
+ * Repository mode.
+ */
+export declare const REPO_MODES: readonly ["repo", "monorepo", "metarepo"];
+export type RepoMode = (typeof REPO_MODES)[number];
+/**
+ * Pack manifest schema (pack.json).
+ */
+export declare const PackManifestSchema: z.ZodObject<{
+    name: z.ZodString;
+    version: z.ZodDefault<z.ZodString>;
+    description: z.ZodDefault<z.ZodString>;
+    author: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        name: z.ZodString;
+        email: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>]>>;
+    tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    dependencies: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    conflicts: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    targets: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
+    features: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
+}, z.core.$strip>;
+export type PackManifest = z.infer<typeof PackManifestSchema>;
+/**
+ * Workspace configuration schema (agentpacks.jsonc).
+ */
+export declare const WorkspaceConfigSchema: z.ZodObject<{
+    $schema: z.ZodOptional<z.ZodString>;
+    packs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    disabled: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    targets: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>;
+    features: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>, z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodLiteral<"*">, z.ZodArray<z.ZodString>]>>]>>;
+    mode: z.ZodDefault<z.ZodEnum<{
+        repo: "repo";
+        monorepo: "monorepo";
+        metarepo: "metarepo";
+    }>>;
+    baseDirs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    global: z.ZodDefault<z.ZodBoolean>;
+    delete: z.ZodDefault<z.ZodBoolean>;
+    verbose: z.ZodDefault<z.ZodBoolean>;
+    silent: z.ZodDefault<z.ZodBoolean>;
+    overrides: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodString>>>;
+    sources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        source: z.ZodString;
+        packs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>;
+export type WorkspaceConfig = z.infer<typeof WorkspaceConfigSchema>;
+/**
+ * Load workspace configuration from the project root.
+ */
+export declare function loadWorkspaceConfig(projectRoot: string): WorkspaceConfig;
+/**
+ * Load pack manifest from a pack directory.
+ */
+export declare function loadPackManifest(packDir: string): PackManifest;
+/**
+ * Resolve which features to generate for a given target.
+ */
+export declare function resolveFeatures(config: WorkspaceConfig, targetId: string): FeatureId[];
+/**
+ * Resolve which targets to generate for.
+ */
+export declare function resolveTargets(config: WorkspaceConfig): string[];

package/dist/core/config.js

@@ -0,0 +1,181 @@
+// @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"];
+});
+init_config();
+
+export {
+  resolveTargets,
+  resolveFeatures,
+  loadWorkspaceConfig,
+  loadPackManifest,
+  WorkspaceConfigSchema,
+  TARGET_IDS,
+  REPO_MODES,
+  PackManifestSchema,
+  FEATURE_IDS
+};

package/dist/core/dependency-resolver.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Pack dependency resolution — topological sort and conflict detection.
+ * Pure algorithm, no I/O.
+ */
+import type { PackManifest } from './config.js';
+/**
+ * A node in the dependency graph.
+ */
+export interface DependencyNode {
+    name: string;
+    manifest: PackManifest;
+    dependencies: string[];
+    conflicts: string[];
+}
+/**
+ * Resolution result.
+ */
+export interface DependencyResolution {
+    /** Packs in topological order (dependencies first). */
+    sorted: string[];
+    /** Circular dependency cycles detected. */
+    cycles: string[][];
+    /** Conflict pairs: [packA, packB] */
+    conflictPairs: [string, string][];
+    /** Missing dependencies: [pack, missingDep] */
+    missingDeps: [string, string][];
+    /** Whether resolution succeeded without errors. */
+    ok: boolean;
+}
+/**
+ * Build a dependency graph from pack manifests.
+ */
+export declare function buildDependencyGraph(manifests: PackManifest[]): Map<string, DependencyNode>;
+/**
+ * Resolve pack dependencies with topological sort, cycle detection,
+ * and conflict detection.
+ */
+export declare function resolveDependencies(manifests: PackManifest[]): DependencyResolution;