@hasna/configs 0.1.0

package/dist/mcp/index.js

@@ -0,0 +1,662 @@
+#!/usr/bin/env bun
+// @bun
+
+// src/mcp/index.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+
+// src/types/index.ts
+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";
+  }
+}
+
+// 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 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);
+}
+
+// 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";
+
+// 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 getSnapshotByVersion(configId, version, db) {
+  const d = db || getDatabase();
+  return d.query("SELECT * FROM config_snapshots WHERE config_id = ? AND version = ?").get(configId, version);
+}
+
+// src/lib/apply.ts
+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;
+}
+
+// src/db/profiles.ts
+function rowToProfile(row) {
+  return { ...row };
+}
+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 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/mcp/index.ts
+var TOOL_DOCS = {
+  list_configs: "List configs. Params: category?, agent?, kind?, search?. Returns array of config objects.",
+  get_config: "Get a config by id or slug. Returns full config including content.",
+  create_config: "Create a new config. Required: name, content, category. Optional: agent, target_path, kind, format, tags, description, is_template.",
+  update_config: "Update a config by id or slug. Optional: content, name, tags, description, category, agent, target_path.",
+  apply_config: "Apply a config to its target_path on disk. Params: id_or_slug, dry_run?. Returns apply result.",
+  sync_directory: "Sync a directory with the DB. Params: dir, direction ('from_disk'|'to_disk'). Returns sync result.",
+  list_profiles: "List all profiles. Returns array of profile objects.",
+  apply_profile: "Apply all configs in a profile to disk. Params: id_or_slug, dry_run?. Returns array of apply results.",
+  get_snapshot: "Get snapshot(s) for a config. Params: config_id_or_slug, version?. Returns latest snapshot or specific version.",
+  search_tools: "Search tool descriptions. Params: query. Returns matching tool names and descriptions.",
+  describe_tools: "Get full descriptions for tools. Params: names? (array). Returns tool docs."
+};
+var LEAN_TOOLS = [
+  { name: "list_configs", inputSchema: { type: "object", properties: { category: { type: "string" }, agent: { type: "string" }, kind: { type: "string" }, search: { type: "string" } } } },
+  { name: "get_config", inputSchema: { type: "object", properties: { id_or_slug: { type: "string" } }, required: ["id_or_slug"] } },
+  { name: "create_config", inputSchema: { type: "object", properties: { name: { type: "string" }, content: { type: "string" }, category: { type: "string" }, agent: { type: "string" }, target_path: { type: "string" }, kind: { type: "string" }, format: { type: "string" }, tags: { type: "array", items: { type: "string" } }, description: { type: "string" }, is_template: { type: "boolean" } }, required: ["name", "content", "category"] } },
+  { name: "update_config", inputSchema: { type: "object", properties: { id_or_slug: { type: "string" }, content: { type: "string" }, name: { type: "string" }, tags: { type: "array", items: { type: "string" } }, description: { type: "string" }, category: { type: "string" }, agent: { type: "string" }, target_path: { type: "string" } }, required: ["id_or_slug"] } },
+  { name: "apply_config", inputSchema: { type: "object", properties: { id_or_slug: { type: "string" }, dry_run: { type: "boolean" } }, required: ["id_or_slug"] } },
+  { name: "sync_directory", inputSchema: { type: "object", properties: { dir: { type: "string" }, direction: { type: "string" } }, required: ["dir"] } },
+  { name: "list_profiles", inputSchema: { type: "object", properties: {} } },
+  { name: "apply_profile", inputSchema: { type: "object", properties: { id_or_slug: { type: "string" }, dry_run: { type: "boolean" } }, required: ["id_or_slug"] } },
+  { name: "get_snapshot", inputSchema: { type: "object", properties: { config_id_or_slug: { type: "string" }, version: { type: "number" } }, required: ["config_id_or_slug"] } },
+  { name: "search_tools", inputSchema: { type: "object", properties: { query: { type: "string" } }, required: ["query"] } },
+  { name: "describe_tools", inputSchema: { type: "object", properties: { names: { type: "array", items: { type: "string" } } } } }
+];
+function ok(data) {
+  return { content: [{ type: "text", text: JSON.stringify(data) }] };
+}
+function err(msg) {
+  return { content: [{ type: "text", text: JSON.stringify({ error: msg }) }], isError: true };
+}
+var server = new Server({ name: "configs", version: "0.1.0" }, { capabilities: { tools: {} } });
+server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: LEAN_TOOLS }));
+server.setRequestHandler(CallToolRequestSchema, async (req) => {
+  const { name, arguments: args = {} } = req.params;
+  try {
+    switch (name) {
+      case "list_configs": {
+        const configs = listConfigs({
+          category: args["category"] || undefined,
+          agent: args["agent"] || undefined,
+          kind: args["kind"] || undefined,
+          search: args["search"] || undefined
+        });
+        return ok(configs.map((c) => ({ id: c.id, slug: c.slug, name: c.name, category: c.category, agent: c.agent, kind: c.kind, target_path: c.target_path, version: c.version })));
+      }
+      case "get_config": {
+        const c = getConfig(args["id_or_slug"]);
+        return ok(c);
+      }
+      case "create_config": {
+        const c = createConfig({
+          name: args["name"],
+          content: args["content"],
+          category: args["category"],
+          agent: args["agent"] || undefined,
+          target_path: args["target_path"] || undefined,
+          kind: args["kind"] || undefined,
+          format: args["format"] || undefined,
+          tags: args["tags"] || undefined,
+          description: args["description"] || undefined,
+          is_template: args["is_template"] || undefined
+        });
+        return ok({ id: c.id, slug: c.slug, name: c.name });
+      }
+      case "update_config": {
+        const c = updateConfig(args["id_or_slug"], {
+          content: args["content"],
+          name: args["name"],
+          tags: args["tags"],
+          description: args["description"],
+          category: args["category"],
+          agent: args["agent"],
+          target_path: args["target_path"]
+        });
+        return ok({ id: c.id, slug: c.slug, version: c.version });
+      }
+      case "apply_config": {
+        const config = getConfig(args["id_or_slug"]);
+        const result = await applyConfig(config, { dryRun: args["dry_run"] });
+        return ok(result);
+      }
+      case "sync_directory": {
+        const dir = args["dir"];
+        const direction = args["direction"] || "from_disk";
+        const result = direction === "to_disk" ? await syncToDir(dir) : await syncFromDir(dir);
+        return ok(result);
+      }
+      case "list_profiles": {
+        return ok(listProfiles());
+      }
+      case "apply_profile": {
+        const configs = getProfileConfigs(args["id_or_slug"]);
+        const results = await applyConfigs(configs, { dryRun: args["dry_run"] });
+        return ok(results);
+      }
+      case "get_snapshot": {
+        const config = getConfig(args["config_id_or_slug"]);
+        if (args["version"]) {
+          const snap = getSnapshotByVersion(config.id, args["version"]);
+          return snap ? ok(snap) : err("Snapshot not found");
+        }
+        const snaps = listSnapshots(config.id);
+        return ok(snaps[0] ?? null);
+      }
+      case "search_tools": {
+        const query = (args["query"] || "").toLowerCase();
+        const matches = Object.entries(TOOL_DOCS).filter(([k, v]) => k.includes(query) || v.toLowerCase().includes(query)).map(([name2, description]) => ({ name: name2, description }));
+        return ok(matches);
+      }
+      case "describe_tools": {
+        const names = args["names"];
+        if (names) {
+          return ok(Object.fromEntries(names.map((n) => [n, TOOL_DOCS[n] ?? "Unknown tool"])));
+        }
+        return ok(TOOL_DOCS);
+      }
+      default:
+        return err(`Unknown tool: ${name}`);
+    }
+  } catch (e) {
+    return err(e instanceof Error ? e.message : String(e));
+  }
+});
+if (process.argv.includes("--claude")) {
+  const proc = Bun.spawn(["claude", "mcp", "add", "--transport", "stdio", "--scope", "user", "configs", "--", "configs-mcp"], { stdout: "inherit", stderr: "inherit" });
+  await proc.exited;
+  process.exit(0);
+}
+var transport = new StdioServerTransport;
+await server.connect(transport);

package/dist/mcp/mcp.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=mcp.test.d.ts.map

package/dist/mcp/mcp.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp.test.d.ts","sourceRoot":"","sources":["../../src/mcp/mcp.test.ts"],"names":[],"mappings":""}

package/dist/server/index.d.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env bun
+declare const _default: {
+    port: number;
+    fetch: (request: Request, Env?: unknown, executionCtx?: import("hono").ExecutionContext) => Response | Promise<Response>;
+};
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/server/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/server/index.ts"],"names":[],"mappings":";;;;;AA2MA,wBAAgD"}