@hasna/configs 0.1.0

package/dist/index.js

@@ -0,0 +1,896 @@
+// @bun
+// src/types/index.ts
+var CONFIG_KINDS = ["file", "reference"];
+var CONFIG_CATEGORIES = [
+  "agent",
+  "rules",
+  "mcp",
+  "shell",
+  "secrets_schema",
+  "workspace",
+  "git",
+  "tools"
+];
+var CONFIG_AGENTS = [
+  "claude",
+  "codex",
+  "gemini",
+  "zsh",
+  "git",
+  "npm",
+  "global"
+];
+var CONFIG_FORMATS = [
+  "text",
+  "json",
+  "toml",
+  "yaml",
+  "markdown",
+  "ini"
+];
+
+class ConfigNotFoundError extends Error {
+  constructor(id) {
+    super(`Config not found: ${id}`);
+    this.name = "ConfigNotFoundError";
+  }
+}
+
+class ProfileNotFoundError extends Error {
+  constructor(id) {
+    super(`Profile not found: ${id}`);
+    this.name = "ProfileNotFoundError";
+  }
+}
+
+class ConfigApplyError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ConfigApplyError";
+  }
+}
+
+class TemplateRenderError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "TemplateRenderError";
+  }
+}
+// src/db/database.ts
+import { Database } from "bun:sqlite";
+import { existsSync, mkdirSync } from "fs";
+import { dirname, join, resolve } from "path";
+import { randomUUID } from "crypto";
+function getDbPath() {
+  if (process.env["CONFIGS_DB_PATH"]) {
+    return process.env["CONFIGS_DB_PATH"];
+  }
+  const home = process.env["HOME"] || process.env["USERPROFILE"] || "~";
+  return join(home, ".configs", "configs.db");
+}
+function ensureDir(filePath) {
+  if (filePath === ":memory:" || filePath.startsWith("file::memory:"))
+    return;
+  const dir = dirname(resolve(filePath));
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+}
+function uuid() {
+  return randomUUID();
+}
+function now() {
+  return new Date().toISOString();
+}
+function slugify(name) {
+  return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
+}
+var MIGRATIONS = [
+  `
+  CREATE TABLE IF NOT EXISTS configs (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    slug TEXT NOT NULL UNIQUE,
+    kind TEXT NOT NULL DEFAULT 'file',
+    category TEXT NOT NULL,
+    agent TEXT NOT NULL DEFAULT 'global',
+    target_path TEXT,
+    format TEXT NOT NULL DEFAULT 'text',
+    content TEXT NOT NULL DEFAULT '',
+    description TEXT,
+    tags TEXT NOT NULL DEFAULT '[]',
+    is_template INTEGER NOT NULL DEFAULT 0,
+    version INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL,
+    synced_at TEXT
+  );
+
+  CREATE TABLE IF NOT EXISTS config_snapshots (
+    id TEXT PRIMARY KEY,
+    config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
+    content TEXT NOT NULL,
+    version INTEGER NOT NULL,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS profiles (
+    id TEXT PRIMARY KEY,
+    name TEXT NOT NULL,
+    slug TEXT NOT NULL UNIQUE,
+    description TEXT,
+    created_at TEXT NOT NULL,
+    updated_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS profile_configs (
+    profile_id TEXT NOT NULL REFERENCES profiles(id) ON DELETE CASCADE,
+    config_id TEXT NOT NULL REFERENCES configs(id) ON DELETE CASCADE,
+    sort_order INTEGER NOT NULL DEFAULT 0,
+    PRIMARY KEY (profile_id, config_id)
+  );
+
+  CREATE TABLE IF NOT EXISTS machines (
+    id TEXT PRIMARY KEY,
+    hostname TEXT NOT NULL UNIQUE,
+    os TEXT,
+    last_applied_at TEXT,
+    created_at TEXT NOT NULL
+  );
+
+  CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER PRIMARY KEY
+  );
+
+  INSERT OR IGNORE INTO schema_version (version) VALUES (1);
+  `
+];
+var _db = null;
+function getDatabase(path) {
+  if (_db)
+    return _db;
+  const dbPath = path || getDbPath();
+  ensureDir(dbPath);
+  const db = new Database(dbPath);
+  db.run("PRAGMA journal_mode = WAL");
+  db.run("PRAGMA foreign_keys = ON");
+  applyMigrations(db);
+  _db = db;
+  return db;
+}
+function resetDatabase() {
+  _db = null;
+}
+function applyMigrations(db) {
+  let currentVersion = 0;
+  try {
+    const row = db.query("SELECT version FROM schema_version ORDER BY version DESC LIMIT 1").get();
+    currentVersion = row?.version ?? 0;
+  } catch {
+    currentVersion = 0;
+  }
+  for (let i = currentVersion;i < MIGRATIONS.length; i++) {
+    db.run(MIGRATIONS[i]);
+    db.run(`INSERT OR REPLACE INTO schema_version (version) VALUES (${i + 1})`);
+  }
+}
+
+// src/db/configs.ts
+function rowToConfig(row) {
+  return {
+    ...row,
+    tags: JSON.parse(row.tags || "[]"),
+    is_template: !!row.is_template,
+    kind: row.kind,
+    category: row.category,
+    agent: row.agent,
+    format: row.format
+  };
+}
+function uniqueSlug(name, db, excludeId) {
+  const base = slugify(name);
+  let slug = base;
+  let i = 1;
+  while (true) {
+    const existing = db.query("SELECT id FROM configs WHERE slug = ?").get(slug);
+    if (!existing || existing.id === excludeId)
+      return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createConfig(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  const slug = uniqueSlug(input.name, d);
+  const tags = JSON.stringify(input.tags || []);
+  d.run(`INSERT INTO configs (id, name, slug, kind, category, agent, target_path, format, content, description, tags, is_template, version, created_at, updated_at, synced_at)
+     VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, 1, ?, ?, NULL)`, [
+    id,
+    input.name,
+    slug,
+    input.kind ?? "file",
+    input.category,
+    input.agent ?? "global",
+    input.target_path ?? null,
+    input.format ?? "text",
+    input.content,
+    input.description ?? null,
+    tags,
+    input.is_template ? 1 : 0,
+    ts,
+    ts
+  ]);
+  return getConfig(id, d);
+}
+function getConfig(idOrSlug, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM configs WHERE id = ? OR slug = ?").get(idOrSlug, idOrSlug);
+  if (!row)
+    throw new ConfigNotFoundError(idOrSlug);
+  return rowToConfig(row);
+}
+function getConfigById(id, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM configs WHERE id = ?").get(id);
+  if (!row)
+    throw new ConfigNotFoundError(id);
+  return rowToConfig(row);
+}
+function listConfigs(filter, db) {
+  const d = db || getDatabase();
+  const conditions = [];
+  const params = [];
+  if (filter?.category) {
+    conditions.push("category = ?");
+    params.push(filter.category);
+  }
+  if (filter?.agent) {
+    conditions.push("agent = ?");
+    params.push(filter.agent);
+  }
+  if (filter?.kind) {
+    conditions.push("kind = ?");
+    params.push(filter.kind);
+  }
+  if (filter?.is_template !== undefined) {
+    conditions.push("is_template = ?");
+    params.push(filter.is_template ? 1 : 0);
+  }
+  if (filter?.search) {
+    conditions.push("(name LIKE ? OR description LIKE ? OR content LIKE ?)");
+    const q = `%${filter.search}%`;
+    params.push(q, q, q);
+  }
+  if (filter?.tags && filter.tags.length > 0) {
+    const tagConditions = filter.tags.map(() => "tags LIKE ?").join(" OR ");
+    conditions.push(`(${tagConditions})`);
+    for (const tag of filter.tags)
+      params.push(`%"${tag}"%`);
+  }
+  const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+  const rows = d.query(`SELECT * FROM configs ${where} ORDER BY category, name`).all(...params);
+  return rows.map(rowToConfig);
+}
+function updateConfig(idOrSlug, input, db) {
+  const d = db || getDatabase();
+  const existing = getConfig(idOrSlug, d);
+  const ts = now();
+  const updates = ["updated_at = ?", "version = version + 1"];
+  const params = [ts];
+  if (input.name !== undefined) {
+    updates.push("name = ?", "slug = ?");
+    params.push(input.name, uniqueSlug(input.name, d, existing.id));
+  }
+  if (input.kind !== undefined) {
+    updates.push("kind = ?");
+    params.push(input.kind);
+  }
+  if (input.category !== undefined) {
+    updates.push("category = ?");
+    params.push(input.category);
+  }
+  if (input.agent !== undefined) {
+    updates.push("agent = ?");
+    params.push(input.agent);
+  }
+  if (input.target_path !== undefined) {
+    updates.push("target_path = ?");
+    params.push(input.target_path);
+  }
+  if (input.format !== undefined) {
+    updates.push("format = ?");
+    params.push(input.format);
+  }
+  if (input.content !== undefined) {
+    updates.push("content = ?");
+    params.push(input.content);
+  }
+  if (input.description !== undefined) {
+    updates.push("description = ?");
+    params.push(input.description);
+  }
+  if (input.tags !== undefined) {
+    updates.push("tags = ?");
+    params.push(JSON.stringify(input.tags));
+  }
+  if (input.is_template !== undefined) {
+    updates.push("is_template = ?");
+    params.push(input.is_template ? 1 : 0);
+  }
+  if (input.synced_at !== undefined) {
+    updates.push("synced_at = ?");
+    params.push(input.synced_at);
+  }
+  params.push(existing.id);
+  d.run(`UPDATE configs SET ${updates.join(", ")} WHERE id = ?`, params);
+  return getConfigById(existing.id, d);
+}
+function deleteConfig(idOrSlug, db) {
+  const d = db || getDatabase();
+  const existing = getConfig(idOrSlug, d);
+  d.run("DELETE FROM configs WHERE id = ?", [existing.id]);
+}
+function getConfigStats(db) {
+  const d = db || getDatabase();
+  const rows = d.query("SELECT category, COUNT(*) as count FROM configs GROUP BY category").all();
+  const stats = { total: 0 };
+  for (const row of rows) {
+    stats[row.category] = row.count;
+    stats["total"] = (stats["total"] || 0) + row.count;
+  }
+  return stats;
+}
+// src/db/snapshots.ts
+function createSnapshot(configId, content, version, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  d.run("INSERT INTO config_snapshots (id, config_id, content, version, created_at) VALUES (?, ?, ?, ?, ?)", [id, configId, content, version, ts]);
+  return { id, config_id: configId, content, version, created_at: ts };
+}
+function listSnapshots(configId, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? ORDER BY version DESC").all(configId);
+}
+function getSnapshot(id, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE id = ?").get(id);
+}
+function getSnapshotByVersion(configId, version, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? AND version = ?").get(configId, version);
+}
+function pruneSnapshots(configId, keep = 10, db) {
+  const d = db || getDatabase();
+  const result = d.run(`DELETE FROM config_snapshots WHERE config_id = ? AND id NOT IN (
+      SELECT id FROM config_snapshots WHERE config_id = ? ORDER BY version DESC LIMIT ?
+    )`, [configId, configId, keep]);
+  return result.changes;
+}
+// src/db/profiles.ts
+function rowToProfile(row) {
+  return { ...row };
+}
+function uniqueProfileSlug(name, db, excludeId) {
+  const base = slugify(name);
+  let slug = base;
+  let i = 1;
+  while (true) {
+    const existing = db.query("SELECT id FROM profiles WHERE slug = ?").get(slug);
+    if (!existing || existing.id === excludeId)
+      return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createProfile(input, db) {
+  const d = db || getDatabase();
+  const id = uuid();
+  const ts = now();
+  const slug = uniqueProfileSlug(input.name, d);
+  d.run("INSERT INTO profiles (id, name, slug, description, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?)", [id, input.name, slug, input.description ?? null, ts, ts]);
+  return getProfile(id, d);
+}
+function getProfile(idOrSlug, db) {
+  const d = db || getDatabase();
+  const row = d.query("SELECT * FROM profiles WHERE id = ? OR slug = ?").get(idOrSlug, idOrSlug);
+  if (!row)
+    throw new ProfileNotFoundError(idOrSlug);
+  return rowToProfile(row);
+}
+function listProfiles(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM profiles ORDER BY name").all().map(rowToProfile);
+}
+function updateProfile(idOrSlug, input, db) {
+  const d = db || getDatabase();
+  const existing = getProfile(idOrSlug, d);
+  const ts = now();
+  const updates = ["updated_at = ?"];
+  const params = [ts];
+  if (input.name !== undefined) {
+    updates.push("name = ?", "slug = ?");
+    params.push(input.name, uniqueProfileSlug(input.name, d, existing.id));
+  }
+  if (input.description !== undefined) {
+    updates.push("description = ?");
+    params.push(input.description);
+  }
+  params.push(existing.id);
+  d.run(`UPDATE profiles SET ${updates.join(", ")} WHERE id = ?`, params);
+  return getProfile(existing.id, d);
+}
+function deleteProfile(idOrSlug, db) {
+  const d = db || getDatabase();
+  const existing = getProfile(idOrSlug, d);
+  d.run("DELETE FROM profiles WHERE id = ?", [existing.id]);
+}
+function addConfigToProfile(profileIdOrSlug, configId, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  const maxRow = d.query("SELECT MAX(sort_order) as max_order FROM profile_configs WHERE profile_id = ?").get(profile.id);
+  const order = (maxRow?.max_order ?? -1) + 1;
+  d.run("INSERT OR IGNORE INTO profile_configs (profile_id, config_id, sort_order) VALUES (?, ?, ?)", [profile.id, configId, order]);
+}
+function removeConfigFromProfile(profileIdOrSlug, configId, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  d.run("DELETE FROM profile_configs WHERE profile_id = ? AND config_id = ?", [profile.id, configId]);
+}
+function getProfileConfigs(profileIdOrSlug, db) {
+  const d = db || getDatabase();
+  const profile = getProfile(profileIdOrSlug, d);
+  const rows = d.query("SELECT config_id FROM profile_configs WHERE profile_id = ? ORDER BY sort_order").all(profile.id);
+  if (rows.length === 0)
+    return [];
+  const ids = rows.map((r) => r.config_id);
+  return listConfigs(undefined, d).filter((c) => ids.includes(c.id));
+}
+// src/db/machines.ts
+import { hostname, type } from "os";
+function currentHostname() {
+  return hostname();
+}
+function currentOs() {
+  return type();
+}
+function registerMachine(hostnameStr, os, db) {
+  const d = db || getDatabase();
+  const h = hostnameStr ?? currentHostname();
+  const o = os ?? currentOs();
+  const existing = d.query("SELECT * FROM machines WHERE hostname = ?").get(h);
+  if (existing)
+    return existing;
+  const id = uuid();
+  const ts = now();
+  d.run("INSERT INTO machines (id, hostname, os, last_applied_at, created_at) VALUES (?, ?, ?, NULL, ?)", [id, h, o, ts]);
+  return d.query("SELECT * FROM machines WHERE id = ?").get(id);
+}
+function updateMachineApplied(hostnameStr, db) {
+  const d = db || getDatabase();
+  const h = hostnameStr ?? currentHostname();
+  d.run("UPDATE machines SET last_applied_at = ? WHERE hostname = ?", [now(), h]);
+}
+function listMachines(db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM machines ORDER BY last_applied_at DESC NULLS LAST").all();
+}
+// src/lib/apply.ts
+import { existsSync as existsSync2, mkdirSync as mkdirSync2, readFileSync, writeFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve2 } from "path";
+import { homedir } from "os";
+function expandPath(p) {
+  if (p.startsWith("~/")) {
+    return resolve2(homedir(), p.slice(2));
+  }
+  return resolve2(p);
+}
+async function applyConfig(config, opts = {}) {
+  if (!config.target_path) {
+    throw new ConfigApplyError(`Config "${config.name}" is a reference (kind=reference) and has no target_path \u2014 cannot apply to disk.`);
+  }
+  const path = expandPath(config.target_path);
+  const previousContent = existsSync2(path) ? readFileSync(path, "utf-8") : null;
+  const changed = previousContent !== config.content;
+  if (!opts.dryRun) {
+    const dir = dirname2(path);
+    if (!existsSync2(dir)) {
+      mkdirSync2(dir, { recursive: true });
+    }
+    if (previousContent !== null && changed) {
+      const db2 = opts.db || getDatabase();
+      createSnapshot(config.id, previousContent, config.version, db2);
+    }
+    writeFileSync(path, config.content, "utf-8");
+    const db = opts.db || getDatabase();
+    updateConfig(config.id, { synced_at: now() }, db);
+  }
+  return {
+    config_id: config.id,
+    path,
+    previous_content: previousContent,
+    new_content: config.content,
+    dry_run: opts.dryRun ?? false,
+    changed
+  };
+}
+async function applyConfigs(configs, opts = {}) {
+  const results = [];
+  for (const config of configs) {
+    if (config.kind === "reference")
+      continue;
+    results.push(await applyConfig(config, opts));
+  }
+  return results;
+}
+// src/lib/sync.ts
+import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
+import { extname, join as join2, relative } from "path";
+import { homedir as homedir2 } from "os";
+function detectCategory(filePath) {
+  const p = filePath.toLowerCase().replace(homedir2(), "~");
+  if (p.includes("/.claude/rules/") || p.endsWith("claude.md") || p.endsWith("agents.md") || p.endsWith("gemini.md"))
+    return "rules";
+  if (p.includes("/.claude/") || p.includes("/.codex/") || p.includes("/.gemini/") || p.includes("/.cursor/"))
+    return "agent";
+  if (p.includes(".mcp.json") || p.includes("mcp"))
+    return "mcp";
+  if (p.includes(".zshrc") || p.includes(".zprofile") || p.includes(".bashrc") || p.includes(".bash_profile"))
+    return "shell";
+  if (p.includes(".gitconfig") || p.includes(".gitignore"))
+    return "git";
+  if (p.includes(".npmrc") || p.includes("tsconfig") || p.includes("bunfig"))
+    return "tools";
+  if (p.includes(".secrets"))
+    return "secrets_schema";
+  return "tools";
+}
+function detectAgent(filePath) {
+  const p = filePath.toLowerCase().replace(homedir2(), "~");
+  if (p.includes("/.claude/") || p.endsWith("claude.md"))
+    return "claude";
+  if (p.includes("/.codex/") || p.endsWith("agents.md"))
+    return "codex";
+  if (p.includes("/.gemini/") || p.endsWith("gemini.md"))
+    return "gemini";
+  if (p.includes(".zshrc") || p.includes(".zprofile") || p.includes(".bashrc"))
+    return "zsh";
+  if (p.includes(".gitconfig") || p.includes(".gitignore"))
+    return "git";
+  if (p.includes(".npmrc"))
+    return "npm";
+  return "global";
+}
+function detectFormat(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (ext === ".json")
+    return "json";
+  if (ext === ".toml")
+    return "toml";
+  if (ext === ".yaml" || ext === ".yml")
+    return "yaml";
+  if (ext === ".md" || ext === ".markdown")
+    return "markdown";
+  if (ext === ".ini" || ext === ".cfg")
+    return "ini";
+  return "text";
+}
+var SKIP_PATTERNS = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
+function shouldSkip(p) {
+  return SKIP_PATTERNS.some((pat) => p.includes(pat));
+}
+function walkDir(dir, files = []) {
+  const entries = readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const full = join2(dir, entry.name);
+    if (shouldSkip(full))
+      continue;
+    if (entry.isDirectory()) {
+      walkDir(full, files);
+    } else if (entry.isFile()) {
+      files.push(full);
+    }
+  }
+  return files;
+}
+async function syncFromDir(dir, opts = {}) {
+  const d = opts.db || getDatabase();
+  const absDir = expandPath(dir);
+  if (!existsSync3(absDir)) {
+    return { added: 0, updated: 0, unchanged: 0, skipped: [`Directory not found: ${absDir}`] };
+  }
+  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync(absDir).map((f) => join2(absDir, f)).filter((f) => statSync(f).isFile());
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const allConfigs = listConfigs(undefined, d);
+  for (const file of files) {
+    if (shouldSkip(file)) {
+      result.skipped.push(file);
+      continue;
+    }
+    try {
+      const content = readFileSync2(file, "utf-8");
+      const targetPath = file.startsWith(homedir2()) ? file.replace(homedir2(), "~") : file;
+      const existing = allConfigs.find((c) => c.target_path === targetPath);
+      if (!existing) {
+        if (!opts.dryRun) {
+          const name = relative(absDir, file);
+          createConfig({
+            name,
+            category: detectCategory(file),
+            agent: detectAgent(file),
+            target_path: targetPath,
+            format: detectFormat(file),
+            content
+          }, d);
+        }
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun) {
+          updateConfig(existing.id, { content }, d);
+        }
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(file);
+    }
+  }
+  return result;
+}
+async function syncToDir(dir, opts = {}) {
+  const d = opts.db || getDatabase();
+  const absDir = expandPath(dir);
+  const normalizedDir = dir.startsWith("~/") ? dir : absDir.replace(homedir2(), "~");
+  const configs = listConfigs(undefined, d).filter((c) => c.target_path && (c.target_path.startsWith(normalizedDir) || c.target_path.startsWith(absDir)));
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  for (const config of configs) {
+    if (config.kind === "reference")
+      continue;
+    try {
+      const r = await applyConfig(config, { dryRun: opts.dryRun, db: d });
+      if (r.changed) {
+        existsSync3(expandPath(config.target_path)) ? result.updated++ : result.added++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(config.target_path || config.id);
+    }
+  }
+  return result;
+}
+function diffConfig(config) {
+  if (!config.target_path)
+    return "(reference \u2014 no target path)";
+  const path = expandPath(config.target_path);
+  if (!existsSync3(path))
+    return `(file not found on disk: ${path})`;
+  const diskContent = readFileSync2(path, "utf-8");
+  if (diskContent === config.content)
+    return "(no diff \u2014 identical)";
+  const stored = config.content.split(`
+`);
+  const disk = diskContent.split(`
+`);
+  const lines = [`--- stored (DB)`, `+++ disk (${path})`];
+  const maxLen = Math.max(stored.length, disk.length);
+  for (let i = 0;i < maxLen; i++) {
+    const s = stored[i];
+    const d = disk[i];
+    if (s === d) {
+      if (s !== undefined)
+        lines.push(` ${s}`);
+    } else {
+      if (s !== undefined)
+        lines.push(`-${s}`);
+      if (d !== undefined)
+        lines.push(`+${d}`);
+    }
+  }
+  return lines.join(`
+`);
+}
+// src/lib/export.ts
+import { existsSync as existsSync4, mkdirSync as mkdirSync3, rmSync, writeFileSync as writeFileSync2 } from "fs";
+import { join as join3, resolve as resolve4 } from "path";
+import { tmpdir } from "os";
+async function exportConfigs(outputPath, opts = {}) {
+  const d = opts.db || getDatabase();
+  const configs = listConfigs(opts.filter, d);
+  const absOutput = resolve4(outputPath);
+  const tmpDir = join3(tmpdir(), `configs-export-${Date.now()}`);
+  const contentsDir = join3(tmpDir, "contents");
+  try {
+    mkdirSync3(contentsDir, { recursive: true });
+    const manifest = {
+      version: "1.0.0",
+      exported_at: now(),
+      configs: configs.map(({ content: _content, ...meta }) => meta)
+    };
+    writeFileSync2(join3(tmpDir, "manifest.json"), JSON.stringify(manifest, null, 2), "utf-8");
+    for (const config of configs) {
+      const fileName = `${config.slug}.${config.format === "text" ? "txt" : config.format}`;
+      writeFileSync2(join3(contentsDir, fileName), config.content, "utf-8");
+    }
+    const proc = Bun.spawn(["tar", "czf", absOutput, "-C", tmpDir, "."], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`tar failed: ${stderr}`);
+    }
+    return { path: absOutput, count: configs.length };
+  } finally {
+    if (existsSync4(tmpDir)) {
+      rmSync(tmpDir, { recursive: true, force: true });
+    }
+  }
+}
+// src/lib/import.ts
+import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync3, rmSync as rmSync2 } from "fs";
+import { join as join4, resolve as resolve5 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+async function importConfigs(bundlePath, opts = {}) {
+  const d = opts.db || getDatabase();
+  const conflict = opts.conflict ?? "skip";
+  const absPath = resolve5(bundlePath);
+  const tmpDir = join4(tmpdir2(), `configs-import-${Date.now()}`);
+  const result = { created: 0, updated: 0, skipped: 0, errors: [] };
+  try {
+    mkdirSync4(tmpDir, { recursive: true });
+    const proc = Bun.spawn(["tar", "xzf", absPath, "-C", tmpDir], {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const stderr = await new Response(proc.stderr).text();
+      throw new Error(`tar extraction failed: ${stderr}`);
+    }
+    const manifestPath = join4(tmpDir, "manifest.json");
+    if (!existsSync5(manifestPath))
+      throw new Error("Invalid bundle: missing manifest.json");
+    const manifest = JSON.parse(readFileSync3(manifestPath, "utf-8"));
+    for (const meta of manifest.configs) {
+      try {
+        const ext = meta.format === "text" ? "txt" : meta.format;
+        const contentFile = join4(tmpDir, "contents", `${meta.slug}.${ext}`);
+        const content = existsSync5(contentFile) ? readFileSync3(contentFile, "utf-8") : "";
+        let existing = null;
+        try {
+          existing = getConfig(meta.slug, d);
+        } catch {}
+        if (existing) {
+          if (conflict === "skip") {
+            result.skipped++;
+          } else if (conflict === "overwrite" || conflict === "version") {
+            updateConfig(existing.id, { content, description: meta.description ?? undefined, tags: meta.tags }, d);
+            result.updated++;
+          }
+        } else {
+          createConfig({
+            name: meta.name,
+            kind: meta.kind,
+            category: meta.category,
+            agent: meta.agent,
+            target_path: meta.target_path ?? undefined,
+            format: meta.format,
+            content,
+            description: meta.description ?? undefined,
+            tags: meta.tags,
+            is_template: meta.is_template
+          }, d);
+          result.created++;
+        }
+      } catch (err) {
+        result.errors.push(`${meta.slug}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+    }
+    return result;
+  } finally {
+    if (existsSync5(tmpDir)) {
+      rmSync2(tmpDir, { recursive: true, force: true });
+    }
+  }
+}
+// src/lib/template.ts
+var VAR_PATTERN = /\{\{([A-Z0-9_]+)(?::([^}]*))?\}\}/g;
+function parseTemplateVars(content) {
+  const names = new Set;
+  let match;
+  VAR_PATTERN.lastIndex = 0;
+  while ((match = VAR_PATTERN.exec(content)) !== null) {
+    names.add(match[1]);
+  }
+  return Array.from(names);
+}
+function extractTemplateVars(content) {
+  const vars = new Map;
+  let match;
+  VAR_PATTERN.lastIndex = 0;
+  while ((match = VAR_PATTERN.exec(content)) !== null) {
+    const name = match[1];
+    const description = match[2] ?? null;
+    if (!vars.has(name)) {
+      vars.set(name, { name, description, required: true });
+    }
+  }
+  return Array.from(vars.values());
+}
+function renderTemplate(content, vars) {
+  const missing = [];
+  VAR_PATTERN.lastIndex = 0;
+  let match;
+  while ((match = VAR_PATTERN.exec(content)) !== null) {
+    const name = match[1];
+    if (!(name in vars))
+      missing.push(name);
+  }
+  if (missing.length > 0) {
+    throw new TemplateRenderError(`Missing required template variables: ${missing.join(", ")}`);
+  }
+  VAR_PATTERN.lastIndex = 0;
+  return content.replace(VAR_PATTERN, (_match, name) => vars[name] ?? "");
+}
+function isTemplate(content) {
+  VAR_PATTERN.lastIndex = 0;
+  return VAR_PATTERN.test(content);
+}
+export {
+  uuid,
+  updateProfile,
+  updateMachineApplied,
+  updateConfig,
+  syncToDir,
+  syncFromDir,
+  slugify,
+  resetDatabase,
+  renderTemplate,
+  removeConfigFromProfile,
+  registerMachine,
+  pruneSnapshots,
+  parseTemplateVars,
+  now,
+  listSnapshots,
+  listProfiles,
+  listMachines,
+  listConfigs,
+  isTemplate,
+  importConfigs,
+  getSnapshotByVersion,
+  getSnapshot,
+  getProfileConfigs,
+  getProfile,
+  getDatabase,
+  getConfigStats,
+  getConfigById,
+  getConfig,
+  extractTemplateVars,
+  exportConfigs,
+  expandPath,
+  diffConfig,
+  detectFormat,
+  detectCategory,
+  detectAgent,
+  deleteProfile,
+  deleteConfig,
+  currentOs,
+  currentHostname,
+  createSnapshot,
+  createProfile,
+  createConfig,
+  applyConfigs,
+  applyConfig,
+  addConfigToProfile,
+  TemplateRenderError,
+  ProfileNotFoundError,
+  ConfigNotFoundError,
+  ConfigApplyError,
+  CONFIG_KINDS,
+  CONFIG_FORMATS,
+  CONFIG_CATEGORIES,
+  CONFIG_AGENTS
+};