@hasna/configs 0.2.2 → 0.2.4

package/dist/cli/index.js

@@ -2064,7 +2064,7 @@ var require_commander = __commonJS((exports) => {
 });
 
 // src/types/index.ts
-var ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError;
+var ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError, TemplateRenderError;
 var init_types = __esm(() => {
   ConfigNotFoundError = class ConfigNotFoundError extends Error {
     constructor(id) {
@@ -2084,6 +2084,12 @@ var init_types = __esm(() => {
       this.name = "ConfigApplyError";
     }
   };
+  TemplateRenderError = class TemplateRenderError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "TemplateRenderError";
+    }
+  };
 });
 
 // src/db/database.ts
@@ -3015,6 +3021,61 @@ var init_sync = __esm(() => {
   ];
 });
 
+// src/lib/template.ts
+var exports_template = {};
+__export(exports_template, {
+  renderTemplate: () => renderTemplate,
+  parseTemplateVars: () => parseTemplateVars,
+  isTemplate: () => isTemplate,
+  extractTemplateVars: () => extractTemplateVars
+});
+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);
+}
+var VAR_PATTERN;
+var init_template = __esm(() => {
+  init_types();
+  VAR_PATTERN = /\{\{([A-Z0-9_]+)(?::([^}]*))?\}\}/g;
+});
+
 // node_modules/commander/esm.mjs
 var import__ = __toESM(require_commander(), 1);
 var {
@@ -3220,24 +3281,8 @@ async function importConfigs(bundlePath, opts = {}) {
   }
 }
 
-// src/lib/template.ts
-init_types();
-var VAR_PATTERN = /\{\{([A-Z0-9_]+)(?::([^}]*))?\}\}/g;
-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());
-}
-
 // src/cli/index.tsx
+init_template();
 import { createRequire } from "module";
 var pkg = createRequire(import.meta.url)("../../package.json");
 function fmtConfig(c, format) {
@@ -3307,7 +3352,7 @@ program.command("add <path>").description("Ingest a file into the config DB").op
   }
   const rawContent = readFileSync5(abs, "utf-8");
   const fmt = detectFormat(abs);
-  const { content, redacted, isTemplate } = redactContent(rawContent, fmt);
+  const { content, redacted, isTemplate: isTemplate2 } = redactContent(rawContent, fmt);
   const targetPath = abs.startsWith(homedir4()) ? abs.replace(homedir4(), "~") : abs;
   const name = opts.name || filePath.split("/").pop();
   const config = createConfig({
@@ -3318,7 +3363,7 @@ program.command("add <path>").description("Ingest a file into the config DB").op
     target_path: opts.kind === "reference" ? null : targetPath,
     format: fmt,
     content,
-    is_template: (opts.template ?? false) || isTemplate
+    is_template: (opts.template ?? false) || isTemplate2
   });
   console.log(chalk.green("\u2713") + ` Added: ${chalk.bold(config.name)} ${chalk.dim(`(${config.slug})`)}`);
   if (redacted.length > 0) {
@@ -3583,6 +3628,54 @@ templateCmd.command("vars <id>").description("Show template variables").action(a
     process.exit(1);
   }
 });
+templateCmd.command("render <id>").description("Render a template config with variables and optionally apply to disk").option("--var <vars...>", "set variables as KEY=VALUE pairs").option("--env", "use environment variables to fill template vars").option("--apply", "write rendered output to target_path").option("--dry-run", "preview rendered output without writing").action(async (id, opts) => {
+  try {
+    const { renderTemplate: renderTemplate2 } = await Promise.resolve().then(() => (init_template(), exports_template));
+    const c = getConfig(id);
+    const vars = {};
+    if (opts.var) {
+      for (const kv of opts.var) {
+        const eq = kv.indexOf("=");
+        if (eq === -1) {
+          console.error(chalk.red(`Invalid --var: ${kv} (expected KEY=VALUE)`));
+          process.exit(1);
+        }
+        vars[kv.slice(0, eq)] = kv.slice(eq + 1);
+      }
+    }
+    if (opts.env) {
+      const { extractTemplateVars: extractTemplateVars2 } = await Promise.resolve().then(() => (init_template(), exports_template));
+      for (const v of extractTemplateVars2(c.content)) {
+        if (!(v.name in vars) && process.env[v.name]) {
+          vars[v.name] = process.env[v.name];
+        }
+      }
+    }
+    const rendered = renderTemplate2(c.content, vars);
+    if (opts.apply || opts.dryRun) {
+      if (!c.target_path) {
+        console.error(chalk.red("No target_path \u2014 cannot apply reference configs"));
+        process.exit(1);
+      }
+      if (opts.dryRun) {
+        console.log(chalk.yellow("[dry-run]") + ` Would write to ${expandPath(c.target_path)}`);
+        console.log(rendered);
+      } else {
+        const { writeFileSync: writeFileSync3, mkdirSync: mkdirSync5 } = await import("fs");
+        const { dirname: dirname3 } = await import("path");
+        const path = expandPath(c.target_path);
+        mkdirSync5(dirname3(path), { recursive: true });
+        writeFileSync3(path, rendered, "utf-8");
+        console.log(chalk.green("\u2713") + ` Rendered and applied to ${path}`);
+      }
+    } else {
+      console.log(rendered);
+    }
+  } catch (e) {
+    console.error(chalk.red(e instanceof Error ? e.message : String(e)));
+    process.exit(1);
+  }
+});
 program.command("scan [id]").description("Scan configs for secrets. Defaults to known configs only.").option("--fix", "redact found secrets in-place").option("--all", "scan every config in the DB (slow on large DBs)").option("-c, --category <cat>", "scan only a specific category").action(async (id, opts) => {
   let configs;
   if (id) {
@@ -3620,8 +3713,8 @@ program.command("scan [id]").description("Scan configs for secrets. Defaults to
       for (const s of secrets)
         console.log(`  line ${s.line}: ${chalk.red(s.varName)} \u2014 ${s.reason}`);
       if (opts.fix) {
-        const { content, isTemplate } = redactContent(c.content, fmt);
-        updateConfig(c.id, { content, is_template: isTemplate });
+        const { content, isTemplate: isTemplate2 } = redactContent(c.content, fmt);
+        updateConfig(c.id, { content, is_template: isTemplate2 });
         console.log(chalk.green("  \u2713 Redacted."));
       }
     }

package/dist/mcp/index.js

@@ -1,32 +1,39 @@
 #!/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";
+var __defProp = Object.defineProperty;
+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);
 
 // 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";
-  }
-}
+var ConfigNotFoundError, ProfileNotFoundError, ConfigApplyError;
+var init_types = __esm(() => {
+  ConfigNotFoundError = class ConfigNotFoundError extends Error {
+    constructor(id) {
+      super(`Config not found: ${id}`);
+      this.name = "ConfigNotFoundError";
+    }
+  };
+  ProfileNotFoundError = class ProfileNotFoundError extends Error {
+    constructor(id) {
+      super(`Profile not found: ${id}`);
+      this.name = "ProfileNotFoundError";
+    }
+  };
+  ConfigApplyError = class ConfigApplyError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "ConfigApplyError";
+    }
+  };
+});
 
 // src/db/database.ts
 import { Database } from "bun:sqlite";
@@ -57,8 +64,35 @@ function now() {
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
-var MIGRATIONS = [
-  `
+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})`);
+  }
+}
+var MIGRATIONS, _db = null;
+var init_database = __esm(() => {
+  MIGRATIONS = [
+    `
   CREATE TABLE IF NOT EXISTS configs (
     id TEXT PRIMARY KEY,
     name TEXT NOT NULL,
@@ -116,33 +150,8 @@ var MIGRATIONS = [
 
   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) {
@@ -295,11 +304,20 @@ function updateConfig(idOrSlug, input, db) {
   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";
+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;
+}
+var init_configs = __esm(() => {
+  init_types();
+  init_database();
+});
 
 // src/db/snapshots.ts
 function createSnapshot(configId, content, version, db) {
@@ -317,8 +335,14 @@ function getSnapshotByVersion(configId, version, db) {
   const d = db || getDatabase();
   return d.query("SELECT * FROM config_snapshots WHERE config_id = ? AND version = ?").get(configId, version);
 }
+var init_snapshots = __esm(() => {
+  init_database();
+});
 
 // 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));
@@ -363,16 +387,192 @@ async function applyConfigs(configs, opts = {}) {
   }
   return results;
 }
+var init_apply = __esm(() => {
+  init_types();
+  init_database();
+  init_configs();
+  init_snapshots();
+});
 
-// src/lib/sync.ts
-import { extname, join as join3 } from "path";
-import { homedir as homedir3 } from "os";
+// src/lib/redact.ts
+function redactShell(content) {
+  const redacted = [];
+  const lines = content.split(`
+`);
+  const out = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/^(\s*(?:export\s+)?)([A-Z][A-Z0-9_]*)(\s*=\s*)(['"]?)(.+?)\4\s*$/);
+    if (m) {
+      const [, prefix, key, eq, quote, value] = m;
+      if (shouldRedactKeyValue(key, value)) {
+        const reason = reasonFor(key, value);
+        redacted.push({ varName: key, line: i + 1, reason });
+        out.push(`${prefix}${key}${eq}${quote}{{${key}}}${quote}`);
+        continue;
+      }
+    }
+    out.push(line);
+  }
+  return { content: out.join(`
+`), redacted, isTemplate: redacted.length > 0 };
+}
+function redactJson(content) {
+  const redacted = [];
+  const lines = content.split(`
+`);
+  const out = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/^(\s*"([^"]+)"\s*:\s*)"([^"]+)"(,?)(\s*)$/);
+    if (m) {
+      const [, prefix, key, value, comma, trail] = m;
+      if (shouldRedactKeyValue(key, value)) {
+        const varName = key.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+        redacted.push({ varName, line: i + 1, reason: reasonFor(key, value) });
+        out.push(`${prefix}"{{${varName}}}"${comma}${trail}`);
+        continue;
+      }
+    }
+    let newLine = line;
+    for (const { re, reason } of VALUE_PATTERNS) {
+      newLine = newLine.replace(re, (match) => {
+        const varName = `REDACTED_${reason.toUpperCase().replace(/[^A-Z0-9]/g, "_")}`;
+        redacted.push({ varName, line: i + 1, reason });
+        return `{{${varName}}}`;
+      });
+    }
+    out.push(newLine);
+  }
+  return { content: out.join(`
+`), redacted, isTemplate: redacted.length > 0 };
+}
+function redactToml(content) {
+  const redacted = [];
+  const lines = content.split(`
+`);
+  const out = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const m = line.match(/^(\s*)([a-zA-Z][a-zA-Z0-9_\-]*)(\s*=\s*)(['"]?)(.+?)\4\s*$/);
+    if (m) {
+      const [, indent, key, eq, quote, value] = m;
+      if (shouldRedactKeyValue(key, value)) {
+        const varName = key.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+        redacted.push({ varName, line: i + 1, reason: reasonFor(key, value) });
+        out.push(`${indent}${key}${eq}${quote}{{${varName}}}${quote}`);
+        continue;
+      }
+    }
+    out.push(line);
+  }
+  return { content: out.join(`
+`), redacted, isTemplate: redacted.length > 0 };
+}
+function redactIni(content) {
+  const redacted = [];
+  const lines = content.split(`
+`);
+  const out = [];
+  for (let i = 0;i < lines.length; i++) {
+    const line = lines[i];
+    const authM = line.match(/^(\/\/[^:]+:_authToken=)(.+)$/);
+    if (authM && !authM[2].startsWith("{{")) {
+      redacted.push({ varName: "NPM_AUTH_TOKEN", line: i + 1, reason: "npm auth token" });
+      out.push(`${authM[1]}{{NPM_AUTH_TOKEN}}`);
+      continue;
+    }
+    const m = line.match(/^(\s*)([a-zA-Z][a-zA-Z0-9_\-]*)(\s*=\s*)(.+?)\s*$/);
+    if (m) {
+      const [, indent, key, eq, value] = m;
+      if (shouldRedactKeyValue(key, value)) {
+        const varName = key.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+        redacted.push({ varName, line: i + 1, reason: reasonFor(key, value) });
+        out.push(`${indent}${key}${eq}{{${varName}}}`);
+        continue;
+      }
+    }
+    out.push(line);
+  }
+  return { content: out.join(`
+`), redacted, isTemplate: redacted.length > 0 };
+}
+function redactGeneric(content) {
+  const redacted = [];
+  const lines = content.split(`
+`);
+  const out = [];
+  for (let i = 0;i < lines.length; i++) {
+    let line = lines[i];
+    for (const { re, reason } of VALUE_PATTERNS) {
+      line = line.replace(re, (match) => {
+        const varName = reason.toUpperCase().replace(/[^A-Z0-9]/g, "_");
+        redacted.push({ varName, line: i + 1, reason });
+        return `{{${varName}}}`;
+      });
+    }
+    out.push(line);
+  }
+  return { content: out.join(`
+`), redacted, isTemplate: redacted.length > 0 };
+}
+function shouldRedactKeyValue(key, value) {
+  if (!value || value.startsWith("{{"))
+    return false;
+  if (value.length < MIN_SECRET_VALUE_LEN)
+    return false;
+  if (/^(true|false|yes|no|on|off|null|undefined|\d+)$/i.test(value))
+    return false;
+  if (SECRET_KEY_PATTERN.test(key))
+    return true;
+  for (const { re } of VALUE_PATTERNS) {
+    if (re.test(value))
+      return true;
+  }
+  return false;
+}
+function reasonFor(key, value) {
+  if (SECRET_KEY_PATTERN.test(key))
+    return `secret key name: ${key}`;
+  for (const { re, reason } of VALUE_PATTERNS) {
+    if (re.test(value))
+      return reason;
+  }
+  return "secret value pattern";
+}
+function redactContent(content, format) {
+  switch (format) {
+    case "shell":
+      return redactShell(content);
+    case "json":
+      return redactJson(content);
+    case "toml":
+      return redactToml(content);
+    case "ini":
+      return redactIni(content);
+    default:
+      return redactGeneric(content);
+  }
+}
+var SECRET_KEY_PATTERN, VALUE_PATTERNS, MIN_SECRET_VALUE_LEN = 8;
+var init_redact = __esm(() => {
+  SECRET_KEY_PATTERN = /^(.*_?API_?KEY|.*_?TOKEN|.*_?SECRET|.*_?PASSWORD|.*_?PASSWD|.*_?CREDENTIAL|.*_?AUTH(?:_TOKEN|_KEY|ORIZATION)?|.*_?PRIVATE_?KEY|.*_?ACCESS_?KEY|.*_?CLIENT_?SECRET|.*_?SIGNING_?KEY|.*_?ENCRYPTION_?KEY|.*_AUTH_TOKEN)$/i;
+  VALUE_PATTERNS = [
+    { re: /npm_[A-Za-z0-9]{36,}/, reason: "npm token" },
+    { re: /gh[pousr]_[A-Za-z0-9_]{36,}/, reason: "GitHub token" },
+    { re: /sk-ant-[A-Za-z0-9\-_]{40,}/, reason: "Anthropic API key" },
+    { re: /sk-[A-Za-z0-9]{48,}/, reason: "OpenAI API key" },
+    { re: /xoxb-[0-9]+-[A-Za-z0-9\-]+/, reason: "Slack bot token" },
+    { re: /AIza[0-9A-Za-z\-_]{35}/, reason: "Google API key" },
+    { re: /ey[A-Za-z0-9_\-]{20,}\.[A-Za-z0-9_\-]{20,}\./, reason: "JWT token" },
+    { re: /AKIA[0-9A-Z]{16}/, reason: "AWS access key" }
+  ];
+});
 
 // src/lib/sync-dir.ts
 import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
 import { join as join2, relative } from "path";
 import { homedir as homedir2 } from "os";
-var SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
 function shouldSkip(p) {
   return SKIP.some((s) => p.includes(s));
 }
@@ -446,7 +646,225 @@ function walkDir(dir, files = []) {
   }
   return files;
 }
+var SKIP;
+var init_sync_dir = __esm(() => {
+  init_database();
+  init_configs();
+  init_apply();
+  init_sync();
+  SKIP = [".db", ".db-shm", ".db-wal", ".log", ".lock", ".DS_Store", "node_modules", ".git"];
+});
+
 // src/lib/sync.ts
+var exports_sync = {};
+__export(exports_sync, {
+  syncToDisk: () => syncToDisk,
+  syncToDir: () => syncToDir,
+  syncProject: () => syncProject,
+  syncKnown: () => syncKnown,
+  syncFromDir: () => syncFromDir,
+  diffConfig: () => diffConfig,
+  detectFormat: () => detectFormat,
+  detectCategory: () => detectCategory,
+  detectAgent: () => detectAgent,
+  PROJECT_CONFIG_FILES: () => PROJECT_CONFIG_FILES,
+  KNOWN_CONFIGS: () => KNOWN_CONFIGS
+});
+import { existsSync as existsSync4, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
+import { extname, join as join3 } from "path";
+import { homedir as homedir3 } from "os";
+async function syncProject(opts) {
+  const d = opts.db || getDatabase();
+  const absDir = expandPath(opts.projectDir);
+  const projectName = absDir.split("/").pop() || "project";
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const allConfigs = listConfigs(undefined, d);
+  for (const pf of PROJECT_CONFIG_FILES) {
+    const abs = join3(absDir, pf.file);
+    if (!existsSync4(abs))
+      continue;
+    try {
+      const rawContent = readFileSync3(abs, "utf-8");
+      if (rawContent.length > 500000) {
+        result.skipped.push(pf.file);
+        continue;
+      }
+      const { content, isTemplate } = redactContent(rawContent, pf.format);
+      const name = `${projectName}/${pf.file}`;
+      const targetPath = abs.replace(homedir3(), "~");
+      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === slug);
+      if (!existing) {
+        if (!opts.dryRun)
+          createConfig({ name, category: pf.category, agent: pf.agent, format: pf.format, content, target_path: targetPath, is_template: isTemplate }, d);
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun)
+          updateConfig(existing.id, { content, is_template: isTemplate }, d);
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(pf.file);
+    }
+  }
+  const rulesDir = join3(absDir, ".claude", "rules");
+  if (existsSync4(rulesDir)) {
+    const mdFiles = readdirSync2(rulesDir).filter((f) => f.endsWith(".md"));
+    for (const f of mdFiles) {
+      const abs = join3(rulesDir, f);
+      const raw = readFileSync3(abs, "utf-8");
+      const { content, isTemplate } = redactContent(raw, "markdown");
+      const name = `${projectName}/rules/${f}`;
+      const targetPath = abs.replace(homedir3(), "~");
+      const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+      const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === slug);
+      if (!existing) {
+        if (!opts.dryRun)
+          createConfig({ name, category: "rules", agent: "claude", format: "markdown", content, target_path: targetPath, is_template: isTemplate }, d);
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun)
+          updateConfig(existing.id, { content, is_template: isTemplate }, d);
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    }
+  }
+  return result;
+}
+async function syncKnown(opts = {}) {
+  const d = opts.db || getDatabase();
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  const home = homedir3();
+  let targets = KNOWN_CONFIGS;
+  if (opts.agent)
+    targets = targets.filter((k) => k.agent === opts.agent);
+  if (opts.category)
+    targets = targets.filter((k) => k.category === opts.category);
+  const allConfigs = listConfigs(undefined, d);
+  for (const known of targets) {
+    if (known.rulesDir) {
+      const absDir = expandPath(known.rulesDir);
+      if (!existsSync4(absDir)) {
+        result.skipped.push(known.rulesDir);
+        continue;
+      }
+      const mdFiles = readdirSync2(absDir).filter((f) => f.endsWith(".md"));
+      for (const f of mdFiles) {
+        const abs2 = join3(absDir, f);
+        const targetPath = abs2.replace(home, "~");
+        const raw = readFileSync3(abs2, "utf-8");
+        const { content, isTemplate } = redactContent(raw, "markdown");
+        const name = `claude-rules-${f}`;
+        const slug = name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
+        const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === slug);
+        if (!existing) {
+          if (!opts.dryRun)
+            createConfig({ name, category: "rules", agent: "claude", format: "markdown", content, target_path: targetPath, is_template: isTemplate }, d);
+          result.added++;
+        } else if (existing.content !== content) {
+          if (!opts.dryRun)
+            updateConfig(existing.id, { content, is_template: isTemplate }, d);
+          result.updated++;
+        } else {
+          result.unchanged++;
+        }
+      }
+      continue;
+    }
+    const abs = expandPath(known.path);
+    if (!existsSync4(abs)) {
+      result.skipped.push(known.path);
+      continue;
+    }
+    try {
+      const rawContent = readFileSync3(abs, "utf-8");
+      if (rawContent.length > 500000) {
+        result.skipped.push(known.path + " (too large)");
+        continue;
+      }
+      const fmt = known.format ?? detectFormat(abs);
+      const { content, isTemplate } = redactContent(rawContent, fmt);
+      const targetPath = abs.replace(home, "~");
+      const existing = allConfigs.find((c) => c.target_path === targetPath || c.slug === known.name);
+      if (!existing) {
+        if (!opts.dryRun) {
+          createConfig({
+            name: known.name,
+            category: known.category,
+            agent: known.agent,
+            format: fmt,
+            content,
+            target_path: known.kind === "reference" ? null : targetPath,
+            kind: known.kind ?? "file",
+            description: known.description,
+            is_template: isTemplate
+          }, d);
+        }
+        result.added++;
+      } else if (existing.content !== content) {
+        if (!opts.dryRun)
+          updateConfig(existing.id, { content, is_template: isTemplate }, d);
+        result.updated++;
+      } else {
+        result.unchanged++;
+      }
+    } catch {
+      result.skipped.push(known.path);
+    }
+  }
+  return result;
+}
+async function syncToDisk(opts = {}) {
+  const d = opts.db || getDatabase();
+  const result = { added: 0, updated: 0, unchanged: 0, skipped: [] };
+  let configs = listConfigs({ kind: "file", ...opts.agent ? { agent: opts.agent } : {}, ...opts.category ? { category: opts.category } : {} }, d);
+  for (const config of configs) {
+    if (!config.target_path)
+      continue;
+    try {
+      const r = await applyConfig(config, { dryRun: opts.dryRun, db: d });
+      r.changed ? result.updated++ : result.unchanged++;
+    } catch {
+      result.skipped.push(config.target_path);
+    }
+  }
+  return result;
+}
+function diffConfig(config) {
+  if (!config.target_path)
+    return "(reference \u2014 no target path)";
+  const path = expandPath(config.target_path);
+  if (!existsSync4(path))
+    return `(file not found on disk: ${path})`;
+  const diskContent = readFileSync3(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 dk = disk[i];
+    if (s === dk) {
+      if (s !== undefined)
+        lines.push(` ${s}`);
+    } else {
+      if (s !== undefined)
+        lines.push(`-${s}`);
+      if (dk !== undefined)
+        lines.push(`+${dk}`);
+    }
+  }
+  return lines.join(`
+`);
+}
 function detectCategory(filePath) {
   const p = filePath.toLowerCase().replace(homedir3(), "~");
   if (p.includes("/.claude/rules/") || p.endsWith("claude.md") || p.endsWith("agents.md") || p.endsWith("gemini.md"))
@@ -495,8 +913,56 @@ function detectFormat(filePath) {
     return "ini";
   return "text";
 }
+var KNOWN_CONFIGS, PROJECT_CONFIG_FILES;
+var init_sync = __esm(() => {
+  init_database();
+  init_configs();
+  init_apply();
+  init_redact();
+  init_sync_dir();
+  KNOWN_CONFIGS = [
+    { path: "~/.claude/CLAUDE.md", name: "claude-claude-md", category: "rules", agent: "claude", format: "markdown" },
+    { path: "~/.claude/settings.json", name: "claude-settings", category: "agent", agent: "claude", format: "json" },
+    { path: "~/.claude/settings.local.json", name: "claude-settings-local", category: "agent", agent: "claude", format: "json" },
+    { path: "~/.claude/keybindings.json", name: "claude-keybindings", category: "agent", agent: "claude", format: "json" },
+    { path: "~/.claude/rules", name: "claude-rules", category: "rules", agent: "claude", rulesDir: "~/.claude/rules" },
+    { path: "~/.codex/config.toml", name: "codex-config", category: "agent", agent: "codex", format: "toml" },
+    { path: "~/.codex/AGENTS.md", name: "codex-agents-md", category: "rules", agent: "codex", format: "markdown" },
+    { path: "~/.gemini/settings.json", name: "gemini-settings", category: "agent", agent: "gemini", format: "json" },
+    { path: "~/.gemini/GEMINI.md", name: "gemini-gemini-md", category: "rules", agent: "gemini", format: "markdown" },
+    { path: "~/.claude.json", name: "claude-json", category: "mcp", agent: "claude", format: "json", description: "Claude Code global config (includes MCP server entries)" },
+    { path: "~/.zshrc", name: "zshrc", category: "shell", agent: "zsh" },
+    { path: "~/.zprofile", name: "zprofile", category: "shell", agent: "zsh" },
+    { path: "~/.bashrc", name: "bashrc", category: "shell", agent: "zsh" },
+    { path: "~/.bash_profile", name: "bash-profile", category: "shell", agent: "zsh" },
+    { path: "~/.gitconfig", name: "gitconfig", category: "git", agent: "git", format: "ini" },
+    { path: "~/.gitignore_global", name: "gitignore-global", category: "git", agent: "git" },
+    { path: "~/.npmrc", name: "npmrc", category: "tools", agent: "npm", format: "ini" },
+    { path: "~/.bunfig.toml", name: "bunfig", category: "tools", agent: "global", format: "toml" }
+  ];
+  PROJECT_CONFIG_FILES = [
+    { file: "CLAUDE.md", category: "rules", agent: "claude", format: "markdown" },
+    { file: ".claude/settings.json", category: "agent", agent: "claude", format: "json" },
+    { file: ".claude/settings.local.json", category: "agent", agent: "claude", format: "json" },
+    { file: ".mcp.json", category: "mcp", agent: "claude", format: "json" },
+    { file: "AGENTS.md", category: "rules", agent: "codex", format: "markdown" },
+    { file: ".codex/AGENTS.md", category: "rules", agent: "codex", format: "markdown" },
+    { file: "GEMINI.md", category: "rules", agent: "gemini", format: "markdown" }
+  ];
+});
+
+// src/mcp/index.ts
+init_configs();
+init_apply();
+init_sync();
+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/db/profiles.ts
+init_types();
+init_database();
+init_configs();
 function rowToProfile(row) {
   return { ...row };
 }
@@ -522,6 +988,8 @@ function getProfileConfigs(profileIdOrSlug, db) {
 }
 
 // src/mcp/index.ts
+init_apply();
+init_snapshots();
 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.",
@@ -532,6 +1000,8 @@ var TOOL_DOCS = {
   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.",
+  get_status: "Single-call orientation. Returns: total configs, counts by category, drifted count, unredacted secrets, templates, DB path.",
+  sync_known: "Sync all known config files from disk into DB. Params: agent?, category?. Replaces sync_directory for standard use.",
   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."
 };
@@ -545,6 +1015,8 @@ var LEAN_TOOLS = [
   { 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: "get_status", inputSchema: { type: "object", properties: {} } },
+  { name: "sync_known", inputSchema: { type: "object", properties: { agent: { type: "string" }, category: { type: "string" } } } },
   { 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" } } } } }
 ];
@@ -628,6 +1100,29 @@ server.setRequestHandler(CallToolRequestSchema, async (req) => {
         const snaps = listSnapshots(config.id);
         return ok(snaps[0] ?? null);
       }
+      case "get_status": {
+        const stats = getConfigStats();
+        const allConfigs = listConfigs({ kind: "file" });
+        let drifted = 0, secrets = 0, templates = 0;
+        for (const c of allConfigs) {
+          if (c.is_template)
+            templates++;
+        }
+        return ok({
+          total: stats["total"] || 0,
+          by_category: Object.fromEntries(Object.entries(stats).filter(([k]) => k !== "total")),
+          templates,
+          db_path: process.env["CONFIGS_DB_PATH"] || "~/.configs/configs.db"
+        });
+      }
+      case "sync_known": {
+        const { syncKnown: syncKnown2 } = await Promise.resolve().then(() => (init_sync(), exports_sync));
+        const result = await syncKnown2({
+          agent: args["agent"] || undefined,
+          category: args["category"] || undefined
+        });
+        return ok(result);
+      }
       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 }));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/configs",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "AI coding agent configuration manager — store, version, apply, and share all your AI coding configs. CLI + MCP + REST API + Dashboard.",
   "type": "module",
   "main": "dist/index.js",