@warpgogol/forge 2.8.0 → 2.8.1

package/src/knowledge/promote.ts

@@ -0,0 +1,156 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Cross-skill duplicate detection and promotion planning for shared knowledge layer (RFC-0663).</purpose>
+<non-goals>
+  <item>Do not read or write files — that is handled by parse.ts/serialize.ts and the distill skill.</item>
+  <item>Do not execute promotions — that is the operator's decision inside fo-knowledge-distill.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0663: initial cross-skill duplicate detection and promotion planning.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { ParsedKnowledgeFile, KnowledgeEntry, KnowledgeEntryMeta } from "./schema.ts";
+
+const STOP_WORDS = new Set(["the", "a", "an"]);
+
+const MIN_CONTAINMENT_LENGTH = 20;
+const MIN_CONTAINMENT_RATIO = 0.6;
+
+export interface DuplicatePair {
+  a: { skill: string; entryId: string; title: string };
+  b: { skill: string; entryId: string; title: string };
+  normalizedTitle: string;
+  kind: "exact" | "containment";
+}
+
+export interface PromotionPlan {
+  sharedEntry: KnowledgeEntry;
+  localPointers: Array<{ skill: string; file: string; entryId: string }>;
+}
+
+export function normalizeTitle(title: string): string {
+  let result = title.toLowerCase();
+  result = result.replace(/[^\p{L}\p{N}\s]/gu, " ");
+  result = result.replace(/\s+/g, " ").trim();
+  const words = result.split(" ").filter((w) => w.length > 0 && !STOP_WORDS.has(w));
+  return words.join(" ");
+}
+
+function isExcludedEntry(meta: KnowledgeEntryMeta): boolean {
+  if (meta.status === "stale" || meta.status === "archived") return true;
+  if (meta.promotedTo !== undefined && meta.promotedTo !== null) return true;
+  return false;
+}
+
+function isLinkedPair(metaA: KnowledgeEntryMeta, metaB: KnowledgeEntryMeta): boolean {
+  if (metaA.supersedes && metaB.id && metaA.supersedes.includes(metaB.id)) return true;
+  if (metaB.supersedes && metaA.id && metaB.supersedes.includes(metaA.id)) return true;
+  if (metaA.promotedTo && metaB.id && metaA.promotedTo === `shared/${metaB.id}`) return true;
+  if (metaB.promotedTo && metaA.id && metaB.promotedTo === `shared/${metaA.id}`) return true;
+  return false;
+}
+
+interface ActiveEntry {
+  skill: string;
+  entry: KnowledgeEntry;
+  normalizedTitle: string;
+}
+
+function collectActiveEntries(
+  files: Array<{ skill: string; parsed: ParsedKnowledgeFile }>,
+): ActiveEntry[] {
+  const active: ActiveEntry[] = [];
+  for (const file of files) {
+    if (file.parsed.isKnowledgeAdjacent) continue;
+    if (file.parsed.parseIssues.length > 0) continue;
+    for (const entry of file.parsed.entries) {
+      if (isExcludedEntry(entry.meta)) continue;
+      const normalized = normalizeTitle(entry.title);
+      if (normalized.length === 0) continue;
+      active.push({ skill: file.skill, entry, normalizedTitle: normalized });
+    }
+  }
+  return active;
+}
+
+export function detectDuplicatePrinciples(
+  files: Array<{ skill: string; parsed: ParsedKnowledgeFile }>,
+): DuplicatePair[] {
+  const active = collectActiveEntries(files);
+  const pairs: DuplicatePair[] = [];
+
+  for (let i = 0; i < active.length; i++) {
+    for (let j = i + 1; j < active.length; j++) {
+      const a = active[i];
+      const b = active[j];
+
+      if (isLinkedPair(a.entry.meta, b.entry.meta)) continue;
+
+      if (a.normalizedTitle === b.normalizedTitle) {
+        pairs.push({
+          a: { skill: a.skill, entryId: a.entry.meta.id, title: a.entry.title },
+          b: { skill: b.skill, entryId: b.entry.meta.id, title: b.entry.title },
+          normalizedTitle: a.normalizedTitle,
+          kind: "exact",
+        });
+        continue;
+      }
+
+      const shorter = a.normalizedTitle.length <= b.normalizedTitle.length ? a : b;
+      const longer = a.normalizedTitle.length <= b.normalizedTitle.length ? b : a;
+
+      if (shorter.normalizedTitle.length < MIN_CONTAINMENT_LENGTH) continue;
+      if (shorter.normalizedTitle.length < longer.normalizedTitle.length * MIN_CONTAINMENT_RATIO)
+        continue;
+
+      if (longer.normalizedTitle.includes(shorter.normalizedTitle)) {
+        pairs.push({
+          a: { skill: a.skill, entryId: a.entry.meta.id, title: a.entry.title },
+          b: { skill: b.skill, entryId: b.entry.meta.id, title: b.entry.title },
+          normalizedTitle: shorter.normalizedTitle,
+          kind: "containment",
+        });
+      }
+    }
+  }
+
+  return pairs;
+}
+
+export function planPromotion(
+  sources: Array<{ skill: string; file: string; entry: KnowledgeEntry }>,
+  merged: { title: string; body: string },
+  nextSharedId: string,
+  today: string,
+): PromotionPlan {
+  const totalConfirmations = sources.reduce((sum, s) => sum + (s.entry.meta.confirmations ?? 0), 0);
+
+  const promotedFrom = sources.map((s) => `${s.skill}/${s.entry.meta.id}`);
+
+  const sharedMeta: KnowledgeEntryMeta = {
+    id: nextSharedId,
+    layer: "L2",
+    created: today,
+    lastConfirmedAt: today,
+    confirmations: totalConfirmations,
+    status: "active",
+    promotedFrom,
+  };
+
+  const sharedEntry: KnowledgeEntry = {
+    meta: sharedMeta,
+    title: merged.title,
+    body: merged.body,
+    lineStart: 0,
+  };
+
+  const localPointers = sources.map((s) => ({
+    skill: s.skill,
+    file: s.file,
+    entryId: s.entry.meta.id,
+  }));
+
+  return { sharedEntry, localPointers };
+}

package/src/knowledge/schema.ts

@@ -0,0 +1,112 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Define the Zod metadata schema for knowledge entries with layer-specific refinements (RFC-0660).</purpose>
+<non-goals>
+  <item>Do not parse markdown — that is handled by parse.ts.</item>
+  <item>Do not serialize — that is handled by serialize.ts.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0660: initial knowledge entry metadata schema with L0/L1/L2 layer-specific refinements.</item>
+  <item>RFC-0663: added promotedFrom field for shared-layer provenance tracking.</item>
+</CHANGE_SUMMARY>
+*/
+
+import { z } from "zod";
+
+export type KnowledgeLayer = "L0" | "L1" | "L2";
+export type KnowledgeEntryStatus = "active" | "stale" | "superseded" | "archived";
+
+const ENTRY_ID_PATTERN = /^K-\d{4}$/;
+const PROMOTED_TO_PATTERN = /^shared\/K-\d{4}$/;
+const PROMOTED_FROM_PATTERN = /^[a-z0-9-]+\/K-\d{4}$/;
+
+const baseMetaSchema = z.object({
+  id: z.string().regex(ENTRY_ID_PATTERN, "id must match ^K-\\d{4}$"),
+  layer: z.enum(["L0", "L1", "L2"]),
+  created: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, "created must be YYYY-MM-DD"),
+  lastConfirmedAt: z.union([z.string().regex(/^\d{4}-\d{2}-\d{2}$/), z.null()]).optional(),
+  confirmations: z.number().int().min(0).optional(),
+  expiresAt: z.union([z.string().regex(/^\d{4}-\d{2}-\d{2}$/), z.null()]).optional(),
+  supersedes: z.array(z.string().regex(ENTRY_ID_PATTERN)).optional(),
+  promotedTo: z.union([z.string().regex(PROMOTED_TO_PATTERN), z.null()]).optional(),
+  promotedFrom: z.array(z.string().regex(PROMOTED_FROM_PATTERN)).optional(),
+  status: z.enum(["active", "stale", "superseded", "archived"]),
+});
+
+export const knowledgeEntryMetaSchema = baseMetaSchema.superRefine((data, ctx) => {
+  if (data.layer === "L0" || data.layer === "L1") {
+    if (data.confirmations !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `confirmations is forbidden on ${data.layer} entries`,
+        path: ["confirmations"],
+      });
+    }
+    if (data.lastConfirmedAt !== undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: `lastConfirmedAt is forbidden on ${data.layer} entries`,
+        path: ["lastConfirmedAt"],
+      });
+    }
+  }
+
+  if (data.layer === "L2") {
+    if (data.confirmations === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "confirmations is required on L2 entries",
+        path: ["confirmations"],
+      });
+    }
+    if (data.lastConfirmedAt === undefined) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: "lastConfirmedAt is required on L2 entries",
+        path: ["lastConfirmedAt"],
+      });
+    }
+  }
+});
+
+export interface KnowledgeEntryMeta {
+  id: string;
+  layer: KnowledgeLayer;
+  created: string;
+  lastConfirmedAt?: string | null;
+  confirmations?: number;
+  expiresAt?: string | null;
+  supersedes?: string[];
+  promotedTo?: string | null;
+  promotedFrom?: string[];
+  status: KnowledgeEntryStatus;
+}
+
+export interface KnowledgeEntry {
+  meta: KnowledgeEntryMeta;
+  title: string;
+  body: string;
+  lineStart: number;
+}
+
+export interface LegacySection {
+  text: string;
+  lineStart: number;
+}
+
+export interface ParseIssue {
+  line: number;
+  message: string;
+  entryId?: string;
+}
+
+export interface ParsedKnowledgeFile {
+  path: string;
+  layer: KnowledgeLayer | null;
+  preamble: string;
+  entries: KnowledgeEntry[];
+  legacySections: LegacySection[];
+  parseIssues: ParseIssue[];
+  isKnowledgeAdjacent: boolean;
+}

package/src/knowledge/serialize.ts

@@ -0,0 +1,72 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Round-trip serializer for knowledge files — reconstructs markdown from ParsedKnowledgeFile (RFC-0660).</purpose>
+<non-goals>
+  <item>Do not parse — that is handled by parse.ts.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0660: initial round-trip serializer for structured knowledge entries.</item>
+  <item>RFC-0663: added promotedFrom to FIELD_ORDER for shared-layer provenance.</item>
+</CHANGE_SUMMARY>
+*/
+
+import type { ParsedKnowledgeFile, KnowledgeEntryMeta } from "./schema.ts";
+
+const FIELD_ORDER: (keyof KnowledgeEntryMeta)[] = [
+  "id",
+  "layer",
+  "created",
+  "lastConfirmedAt",
+  "confirmations",
+  "expiresAt",
+  "supersedes",
+  "promotedTo",
+  "promotedFrom",
+  "status",
+];
+
+function formatYamlValue(value: unknown): string {
+  if (value === null) return "null";
+  if (Array.isArray(value)) {
+    if (value.length === 0) return "[]";
+    return `[${value.join(", ")}]`;
+  }
+  if (typeof value === "string") return value;
+  return String(value);
+}
+
+function serializeMeta(meta: KnowledgeEntryMeta): string {
+  const lines: string[] = ["```knowledge-entry"];
+  for (const field of FIELD_ORDER) {
+    const value = meta[field];
+    if (value === undefined) continue;
+    lines.push(`${field}: ${formatYamlValue(value)}`);
+  }
+  lines.push("```");
+  return lines.join("\n");
+}
+
+export function serializeKnowledgeFile(parsed: ParsedKnowledgeFile): string {
+  const parts: string[] = [];
+
+  if (parsed.preamble) {
+    parts.push(parsed.preamble);
+  }
+
+  for (const entry of parsed.entries) {
+    parts.push(`### ${entry.meta.id}: ${entry.title}`);
+    parts.push("");
+    parts.push(serializeMeta(entry.meta));
+    if (entry.body) {
+      parts.push("");
+      parts.push(entry.body);
+    }
+  }
+
+  for (const legacy of parsed.legacySections) {
+    parts.push(legacy.text);
+  }
+
+  return parts.join("\n").replace(/\n{3,}/g, "\n\n") + "\n";
+}

package/src/migration-adapters/git-utils.ts

@@ -0,0 +1,71 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Shared git utilities for migration adapters — git init and git history transfer via format-patch + git am (RFC-0547).</purpose>
+<non-goals>
+  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not implement adapter-specific logic — only shared git operations.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0547: extract shared postSetup git logic from duplicated adapter implementations.</item>
+  <item>Replace fs.rmSync with trashSync for patch directory cleanup (trash bin for LLM-initiated deletions).</item>
+</CHANGE_SUMMARY>
+*/
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+import { trashSync } from "../utils/fs-trash-sync.ts";
+import type { AdapterAnalysis } from "./types.ts";
+
+export function runPostSetup(
+  sourceDir: string,
+  targetDir: string,
+  analysis: AdapterAnalysis,
+): void {
+  const gitDir = path.join(targetDir, ".git");
+
+  if (analysis.gitHistory) {
+    try {
+      const patchDir = path.join(targetDir, ".forge-migration-patches");
+      fs.mkdirSync(patchDir, { recursive: true });
+      execFileSync("git", ["-C", sourceDir, "format-patch", "--all", "-o", patchDir], {
+        stdio: "pipe",
+      });
+      execFileSync("git", ["init"], { cwd: targetDir, stdio: "pipe" });
+      execFileSync("git", ["config", "user.email", "forge@warpgogol.dev"], {
+        cwd: targetDir,
+        stdio: "pipe",
+      });
+      execFileSync("git", ["config", "user.name", "Forge Migration"], {
+        cwd: targetDir,
+        stdio: "pipe",
+      });
+      const patches = fs
+        .readdirSync(patchDir)
+        .filter((f) => f.endsWith(".patch"))
+        .sort();
+      if (patches.length > 0) {
+        for (const patch of patches) {
+          execFileSync("git", ["am", path.join(patchDir, patch)], {
+            cwd: targetDir,
+            stdio: "pipe",
+          });
+        }
+      }
+      trashSync(patchDir);
+      return;
+    } catch (err) {
+      console.warn(
+        `forge: git history transfer failed, falling back to clean git init: ${err instanceof Error ? err.message : String(err)}`,
+      );
+      if (!fs.existsSync(gitDir)) {
+        execFileSync("git", ["init"], { cwd: targetDir, stdio: "pipe" });
+      }
+    }
+  } else {
+    if (!fs.existsSync(gitDir)) {
+      execFileSync("git", ["init"], { cwd: targetDir, stdio: "pipe" });
+    }
+  }
+}

package/src/migration-adapters/ignored-files.ts

@@ -0,0 +1,221 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Discover and categorize git-ignored/untracked files in a source project for interactive transfer selection during onboarding.</purpose>
+<non-goals>
+  <item>Do not import from @warpgogol/* — this module is portable.</item>
+  <item>Do not copy files — discovery and categorization only.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>Initial: discoverIgnoredFiles function that scans source for git-ignored files, categorizes them by type (config, data, runtime-state, cache, other), and returns sized categories for operator selection.</item>
+</CHANGE_SUMMARY>
+*/
+
+import fs from "node:fs";
+import path from "node:path";
+import { execFileSync } from "node:child_process";
+
+export type IgnoredFileCategoryId = "config" | "data" | "runtime-state" | "cache" | "other";
+
+export interface IgnoredFileCategory {
+  id: IgnoredFileCategoryId;
+  label: string;
+  description: string;
+  paths: string[];
+  totalSizeBytes: number;
+  fileCount: number;
+}
+
+interface CategoryDef {
+  id: IgnoredFileCategoryId;
+  label: string;
+  description: string;
+  matchers: ((relPath: string) => boolean)[];
+}
+
+const CONFIG_MATCHERS: ((p: string) => boolean)[] = [
+  (p) => p === ".env" || p.startsWith(".env."),
+  (p) => p.endsWith(".key") || p.endsWith(".pem") || p.endsWith(".crt"),
+  (p) => p === ".secret" || p.startsWith("secret"),
+  (p) => p.startsWith("secrets/"),
+  (p) => p.includes("/.env") || p.includes("/.env."),
+  (p) => p === ".envrc" || p.startsWith(".envrc."),
+];
+
+const DATA_MATCHERS: ((p: string) => boolean)[] = [
+  (p) => p.startsWith(".input/") || p.includes("/.input/"),
+  (p) => p.startsWith("input/") || p.includes("/input/"),
+  (p) => p.startsWith("inputs/") || p.includes("/inputs/"),
+  (p) => p.startsWith("data/") || p.includes("/data/"),
+  (p) => p.startsWith("assets/") || p.includes("/assets/"),
+  (p) => p.startsWith("batches/") || p.includes("/batches/"),
+  (p) => p.endsWith(".db") || p.endsWith(".sqlite") || p.endsWith(".sqlite3"),
+  (p) => p.endsWith(".ndjson") && !p.startsWith("bordbuch/"),
+];
+
+const RUNTIME_STATE_MATCHERS: ((p: string) => boolean)[] = [
+  (p) => p.startsWith("storage/") || p.includes("/storage/"),
+  (p) => p.startsWith(".state/") || p.includes("/.state/"),
+  (p) => p.startsWith("state/") || p.includes("/state/"),
+  (p) => p.endsWith(".log"),
+];
+
+const CACHE_MATCHERS: ((p: string) => boolean)[] = [
+  (p) => p.startsWith(".cache/") || p.includes("/.cache/"),
+  (p) => p.startsWith("cache/") || p.includes("/cache/"),
+  (p) => p.includes(".playwright") || p.includes("browser-profile"),
+  (p) => p.endsWith(".tmp") || p.startsWith(".tmp"),
+];
+
+const CATEGORY_DEFS: CategoryDef[] = [
+  {
+    id: "config",
+    label: "Configuration & secrets",
+    description:
+      "Environment files, API keys, certificates, and local configuration needed for the project to run.",
+    matchers: CONFIG_MATCHERS,
+  },
+  {
+    id: "data",
+    label: "Data & inputs",
+    description: "Input data, datasets, databases, and batch files used by the project.",
+    matchers: DATA_MATCHERS,
+  },
+  {
+    id: "runtime-state",
+    label: "Runtime state",
+    description: "Crawlee state, logs, and other runtime artifacts from previous executions.",
+    matchers: RUNTIME_STATE_MATCHERS,
+  },
+  {
+    id: "cache",
+    label: "Caches",
+    description: "Browser profiles, temporary files, and build caches that can be regenerated.",
+    matchers: CACHE_MATCHERS,
+  },
+  {
+    id: "other",
+    label: "Other ignored files",
+    description: "Files matched by .gitignore that don't fit into any standard category.",
+    matchers: [],
+  },
+];
+
+const CATEGORY_PRIORITY: Record<IgnoredFileCategoryId, number> = {
+  config: 0,
+  data: 1,
+  "runtime-state": 2,
+  cache: 3,
+  other: 4,
+};
+
+function categorizePath(relPath: string): CategoryDef {
+  const normalized = relPath.replace(/\\/g, "/");
+  for (const def of CATEGORY_DEFS) {
+    if (def.matchers.some((m) => m(normalized))) {
+      return def;
+    }
+  }
+  return CATEGORY_DEFS[CATEGORY_DEFS.length - 1];
+}
+
+function getDirStats(dirPath: string): { size: number; count: number } {
+  let size = 0;
+  let count = 0;
+  try {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    for (const entry of entries) {
+      const fullPath = path.join(dirPath, entry.name);
+      if (entry.isDirectory()) {
+        const sub = getDirStats(fullPath);
+        size += sub.size;
+        count += sub.count;
+      } else if (entry.isFile()) {
+        try {
+          size += fs.statSync(fullPath).size;
+          count++;
+        } catch {
+          // File may have been removed
+        }
+      }
+    }
+  } catch {
+    // Directory may have been removed
+  }
+  return { size, count };
+}
+
+function getPathSize(fullPath: string): { sizeBytes: number; fileCount: number } {
+  try {
+    const stat = fs.statSync(fullPath);
+    if (stat.isDirectory()) {
+      const { size, count } = getDirStats(fullPath);
+      return { sizeBytes: size, fileCount: count };
+    }
+    return { sizeBytes: stat.size, fileCount: 1 };
+  } catch {
+    return { sizeBytes: 0, fileCount: 0 };
+  }
+}
+
+export function discoverIgnoredFiles(sourceDir: string): IgnoredFileCategory[] {
+  const hasGit = fs.existsSync(path.join(sourceDir, ".git"));
+  let ignoredPaths: string[] = [];
+
+  if (hasGit) {
+    try {
+      const output = execFileSync("git", ["-C", sourceDir, "status", "--ignored", "--porcelain"], {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"],
+        timeout: 30_000,
+      });
+      ignoredPaths = output
+        .split("\n")
+        .filter((l) => l.startsWith("!! "))
+        .map((l) => l.slice(3).trim())
+        .filter((p) => p.length > 0);
+    } catch {
+      // git command failed — return empty
+      return [];
+    }
+  }
+
+  if (ignoredPaths.length === 0) {
+    return [];
+  }
+
+  const categoryMap = new Map<IgnoredFileCategoryId, IgnoredFileCategory>();
+
+  for (const relPath of ignoredPaths) {
+    const fullPath = path.join(sourceDir, relPath);
+    const def = categorizePath(relPath);
+    const { sizeBytes, fileCount } = getPathSize(fullPath);
+
+    if (!categoryMap.has(def.id)) {
+      categoryMap.set(def.id, {
+        id: def.id,
+        label: def.label,
+        description: def.description,
+        paths: [],
+        totalSizeBytes: 0,
+        fileCount: 0,
+      });
+    }
+
+    const cat = categoryMap.get(def.id)!;
+    cat.paths.push(relPath);
+    cat.totalSizeBytes += sizeBytes;
+    cat.fileCount += fileCount;
+  }
+
+  return Array.from(categoryMap.values()).sort(
+    (a, b) => CATEGORY_PRIORITY[a.id] - CATEGORY_PRIORITY[b.id],
+  );
+}
+
+export function formatSize(bytes: number): string {
+  if (bytes < 1024) return `${bytes} B`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
+}

package/src/migration-adapters/index.ts

@@ -0,0 +1,21 @@
+/*
+<MODULE_CONTRACT>
+<purpose>Barrel export for migration-adapter module (RFC-0546).</purpose>
+<non-goals>
+  <item>Do not re-export implementation details — only public types and registry functions.</item>
+</non-goals>
+</MODULE_CONTRACT>
+<CHANGE_SUMMARY>
+  <item>RFC-0546: initial barrel export for migration-adapters.</item>
+</CHANGE_SUMMARY>
+*/
+
+export type { MigrationAdapter, AdapterAnalysis, MigrationResult, Conflict } from "./types.ts";
+
+export { FORGE_PROTECTED_PATHS, DEFAULT_EXCLUDE_PATTERNS } from "./types.ts";
+
+export { nodeTypescriptPnpmAdapter } from "./node-typescript-pnpm/index.ts";
+export { phaserPnpmAdapter } from "./phaser-pnpm/index.ts";
+export { getAdapters, detectAdapter, detectAdapters } from "./registry.ts";
+export { discoverIgnoredFiles, formatSize } from "./ignored-files.ts";
+export type { IgnoredFileCategory, IgnoredFileCategoryId } from "./ignored-files.ts";