@hasna/configs 0.2.5 → 0.2.7

package/README.md

@@ -6,9 +6,10 @@ AI coding agent configuration manager — store, version, apply, and share all y
 
 ```bash
 bun install -g @hasna/configs
-configs sync --dir ~/.claude     # ingest all Claude Code configs
-configs whoami                   # see what's stored
-configs apply claude-claude-md   # write a config back to disk
+configs init                     # first-time setup: sync all known configs + create profile
+configs status                   # health check: drifted, secrets, templates
+configs pull                     # re-sync from disk → DB
+configs push                     # apply DB → disk
 ```
 
 ## What It Stores
@@ -84,22 +85,35 @@ configs add <path>        ingest a file into the DB
 configs apply <id>        write config to its target_path
   --dry-run               preview without writing
 
-configs diff <id>         show diff: stored vs disk
+configs diff [id]         show diff: stored vs disk (omit id for all)
+configs compare <a> <b>   diff two stored configs against each other
 
-configs sync              bulk sync a directory
-  -d, --dir <dir>         directory (default: ~/.claude)
-  --from-disk             read files from disk into DB (default)
-  --to-disk               apply DB configs back to disk
+configs sync              sync known AI coding configs from disk
+  -a, --agent <agent>     only sync this agent
+  -p, --project [dir]     sync project-scoped configs (CLAUDE.md, .mcp.json)
+  --to-disk               apply DB → disk instead
   --dry-run               preview
+  --list                  show which files would be synced
 
-configs export            export as tar.gz bundle
-  -o, --output <path>     output file (default: ./configs-export.tar.gz)
-  -c, --category <cat>    filter by category
-
-configs import <file>     import from tar.gz bundle
-  --overwrite             overwrite existing configs
+configs pull              alias for sync (disk → DB)
+configs push              alias for sync --to-disk (DB → disk)
 
-configs whoami            setup summary (DB path, counts by category)
+configs export            export as tar.gz bundle
+configs import <file>     import from tar.gz bundle (--overwrite)
+configs backup            timestamped export to ~/.configs/backups/
+configs restore <file>    import from backup (--overwrite)
+
+configs init              first-time setup: sync + seed + create profile
+configs status            health check: drifted, secrets, templates
+configs whoami            setup summary: DB path, counts by category
+configs doctor            validate syntax, permissions, missing files, secrets
+configs scan [id]         scan for unredacted secrets (--fix to redact)
+configs watch             auto-sync on file changes (polls every 3s)
+configs update            check for + install latest version
+configs completions       output zsh/bash completion script
+
+configs mcp install       install MCP server (--claude, --codex, --gemini, --all)
+configs mcp uninstall     remove MCP server
 ```
 
 ### Profiles
@@ -127,12 +141,26 @@ configs snapshot show <snapshot-id>       # view content
 configs snapshot restore <config> <id>    # restore to that version
 ```
 
-### Templates
+### Templates & Secret Redaction
+
+Secrets are automatically redacted when ingesting configs. Values matching API keys, tokens, passwords etc. are replaced with `{{VAR_NAME}}` placeholders.
+
+```bash
+configs template vars npmrc              # show: {{NPM_AUTH_TOKEN}}
+configs template render npmrc --env --apply  # fill from env vars, write to disk
+configs template render npmrc --var NPM_AUTH_TOKEN=xxx --dry-run  # preview
+configs scan                             # check for unredacted secrets
+configs scan --fix                       # redact any that slipped through
+```
+
+### Agent Profiles (Token Optimization)
 
-Configs with `{{VAR_NAME}}` placeholders are templates.
+Control which MCP tools are exposed via `CONFIGS_PROFILE` env var:
 
 ```bash
-configs template vars my-zshrc-template   # show required variables
+CONFIGS_PROFILE=minimal configs-mcp   # 3 tools: get_status, get_config, sync_known
+CONFIGS_PROFILE=standard configs-mcp  # 11 tools: CRUD + sync + profiles
+CONFIGS_PROFILE=full configs-mcp      # 13 tools (default)
 ```
 
 ## MCP Server

package/dist/mcp/index.js

@@ -1005,7 +1005,14 @@ var TOOL_DOCS = {
   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 = [
+var PROFILES = {
+  minimal: ["get_status", "get_config", "sync_known"],
+  standard: ["list_configs", "get_config", "create_config", "update_config", "apply_config", "sync_known", "get_status", "list_profiles", "apply_profile", "search_tools", "describe_tools"],
+  full: []
+};
+var activeProfile = process.env["CONFIGS_PROFILE"] || "full";
+var profileFilter = PROFILES[activeProfile];
+var ALL_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"] } },
@@ -1027,6 +1034,7 @@ 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: {} } });
+var LEAN_TOOLS = profileFilter && profileFilter.length > 0 ? ALL_LEAN_TOOLS.filter((t) => profileFilter.includes(t.name)) : ALL_LEAN_TOOLS;
 server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: LEAN_TOOLS }));
 server.setRequestHandler(CallToolRequestSchema, async (req) => {
   const { name, arguments: args = {} } = req.params;

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

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

package/dist/server/index.js

@@ -2083,64 +2083,188 @@ async function applyConfigs(configs, opts = {}) {
   return results;
 }
 
-// src/lib/sync-dir.ts
-import { existsSync as existsSync3, readdirSync, readFileSync as readFileSync2, statSync } from "fs";
-import { join as join3, relative } from "path";
+// src/lib/sync.ts
+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";
 
-// src/lib/sync.ts
-import { extname, join as join2 } 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";
+// src/lib/redact.ts
+var 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;
+var 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" }
+];
+var MIN_SECRET_VALUE_LEN = 8;
+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 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 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, (match2) => {
+        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 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";
+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, (match2) => {
+        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);
+  }
 }
 
 // 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));
@@ -2150,9 +2274,9 @@ async function syncFromDir(dir, opts = {}) {
   const absDir = expandPath(dir);
   if (!existsSync3(absDir))
     return { added: 0, updated: 0, unchanged: 0, skipped: [`Not found: ${absDir}`] };
-  const files = opts.recursive !== false ? walkDir(absDir) : readdirSync(absDir).map((f) => join3(absDir, f)).filter((f) => statSync(f).isFile());
+  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 home = homedir3();
+  const home = homedir2();
   const allConfigs = listConfigs(undefined, d);
   for (const file of files) {
     if (shouldSkip(file)) {
@@ -2186,7 +2310,7 @@ async function syncFromDir(dir, opts = {}) {
 }
 async function syncToDir(dir, opts = {}) {
   const d = opts.db || getDatabase();
-  const home = homedir3();
+  const home = homedir2();
   const absDir = expandPath(dir);
   const normalized = dir.startsWith("~/") ? dir : absDir.replace(home, "~");
   const configs = listConfigs(undefined, d).filter((c) => c.target_path && (c.target_path.startsWith(normalized) || c.target_path.startsWith(absDir)));
@@ -2205,7 +2329,7 @@ async function syncToDir(dir, opts = {}) {
 }
 function walkDir(dir, files = []) {
   for (const entry of readdirSync(dir, { withFileTypes: true })) {
-    const full = join3(dir, entry.name);
+    const full = join2(dir, entry.name);
     if (shouldSkip(full))
       continue;
     if (entry.isDirectory())
@@ -2216,8 +2340,161 @@ function walkDir(dir, files = []) {
   return files;
 }
 
+// src/lib/sync.ts
+var 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" }
+];
+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 raw2 = readFileSync3(abs2, "utf-8");
+        const { content, isTemplate } = redactContent(raw2, "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;
+}
+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"))
+    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(homedir3(), "~");
+  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";
+}
+
 // src/server/index.ts
-import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
+import { existsSync as existsSync5, readFileSync as readFileSync4 } from "fs";
 import { join as join4, extname as extname2 } from "path";
 var PORT = Number(process.env["CONFIGS_PORT"] ?? 3457);
 function pickFields(obj, fields) {
@@ -2229,6 +2506,30 @@ function pickFields(obj, fields) {
 var app = new Hono2;
 app.use("*", cors());
 app.get("/api/stats", (c) => c.json(getConfigStats()));
+app.get("/api/status", (c) => {
+  const stats = getConfigStats();
+  const allConfigs = listConfigs({ kind: "file" });
+  let templates = 0;
+  for (const cfg of allConfigs) {
+    if (cfg.is_template)
+      templates++;
+  }
+  return c.json({
+    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"
+  });
+});
+app.post("/api/sync-known", async (c) => {
+  try {
+    const body = await c.req.json().catch(() => ({}));
+    const result = await syncKnown({ agent: body.agent, category: body.category, dryRun: body.dry_run });
+    return c.json(result);
+  } catch (e) {
+    return c.json({ error: e instanceof Error ? e.message : String(e) }, 422);
+  }
+});
 app.get("/api/configs", (c) => {
   const { category, agent, kind, search, fields } = c.req.query();
   const configs = listConfigs({
@@ -2388,7 +2689,7 @@ function findDashboardDir() {
     join4(import.meta.dir, "../../../dashboard/dist")
   ];
   for (const dir of candidates) {
-    if (existsSync4(join4(dir, "index.html")))
+    if (existsSync5(join4(dir, "index.html")))
       return dir;
   }
   return null;
@@ -2399,11 +2700,11 @@ if (dashDir) {
     const url = new URL(c.req.url);
     let filePath = url.pathname === "/" ? "/index.html" : url.pathname;
     let absPath = join4(dashDir, filePath);
-    if (!existsSync4(absPath))
+    if (!existsSync5(absPath))
       absPath = join4(dashDir, "index.html");
-    if (!existsSync4(absPath))
+    if (!existsSync5(absPath))
       return c.json({ error: "Not found" }, 404);
-    const content = readFileSync3(absPath);
+    const content = readFileSync4(absPath);
     const ext = extname2(absPath);
     return new Response(content, {
       headers: { "Content-Type": MIME[ext] || "application/octet-stream" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hasna/configs",
-  "version": "0.2.5",
+  "version": "0.2.7",
   "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",