@dotformat/cli 0.1.1 → 0.2.0

package/bin/dotfiles.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env bun
+import "../src/cli";

package/package.json

@@ -1,14 +1,19 @@
 {
   "name": "@dotformat/cli",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "Collect, compare, and sync machine configs across machines",
   "type": "module",
   "bin": {
-    "dotfiles": "./bin/dotfiles.js"
+    "dotfiles": "./bin/dotfiles.ts"
+  },
+  "scripts": {
+    "collect": "bun bin/dotfiles.ts collect",
+    "compare": "bun bin/dotfiles.ts compare",
+    "test": "bun test"
   },
   "files": [
-    "bin/dotfiles.js",
-    "setup/collect-machine-config.sh"
+    "bin/dotfiles.ts",
+    "src/"
   ],
   "keywords": [
     "dotfiles",
@@ -23,5 +28,11 @@
     "type": "git",
     "url": "git+https://github.com/doguyilmaz/dotfiles.git"
   },
-  "homepage": "https://github.com/doguyilmaz/dotfiles#readme"
+  "homepage": "https://github.com/doguyilmaz/dotfiles#readme",
+  "dependencies": {
+    "@dotformat/core": "^0.2.0"
+  },
+  "devDependencies": {
+    "@types/bun": "latest"
+  }
 }

package/src/cli.ts

@@ -0,0 +1,24 @@
+import { collect } from "./commands/collect";
+import { compareCli } from "./commands/compare";
+import { list } from "./commands/list";
+
+const [command, ...args] = Bun.argv.slice(2);
+
+switch (command) {
+  case "collect":
+    await collect(args);
+    break;
+  case "compare":
+    await compareCli(args);
+    break;
+  case "list":
+    await list(args);
+    break;
+  default:
+    console.log(`Usage: dotfiles <command>
+
+Commands:
+  collect [--no-redact] [-o path]   Collect machine config → .dotf report
+  compare [file1] [file2]           Diff two .dotf reports
+  list <section>                    Print a section from most recent report`);
+}

package/src/collectors/apps.ts

@@ -0,0 +1,43 @@
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectApps: Collector = async () => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+
+  const raycastInstalled = await Bun.file("/Applications/Raycast.app/Contents/Info.plist").exists();
+  result["apps.raycast"] = makeSection("apps.raycast", {
+    pairs: { installed: raycastInstalled ? "true" : "false" },
+  });
+
+  const alttabInstalled = await Bun.file("/Applications/AltTab.app/Contents/Info.plist").exists();
+  const alttabPairs: Record<string, string> = {
+    installed: alttabInstalled ? "true" : "false",
+  };
+
+  if (alttabInstalled) {
+    try {
+      const prefs = await Bun.$`defaults read com.lwouis.alt-tab-macos 2>/dev/null`.text();
+      if (prefs.trim()) alttabPairs.preferences = "exists";
+    } catch {}
+  }
+
+  result["apps.alttab"] = makeSection("apps.alttab", { pairs: alttabPairs });
+
+  try {
+    const appsOutput = await Bun.$`ls /Applications/`.text();
+    const apps = appsOutput
+      .trim()
+      .split("\n")
+      .map((a) => a.trim())
+      .filter(Boolean)
+      .sort();
+
+    if (apps.length) {
+      result["apps.macos"] = makeSection("apps.macos", {
+        items: apps.map((a) => ({ raw: a, columns: [a] })),
+      });
+    }
+  } catch {}
+
+  return result;
+};

package/src/collectors/bun-config.ts

@@ -0,0 +1,14 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectBunConfig: Collector = async (ctx) => {
+  const bunfigFile = Bun.file(join(ctx.home, ".bunfig.toml"));
+
+  if (!(await bunfigFile.exists())) return {};
+
+  const content = await bunfigFile.text();
+  return {
+    "bun.config": makeSection("bun.config", { content: content.trim() }),
+  };
+};

package/src/collectors/claude.ts

@@ -0,0 +1,46 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectClaude: Collector = async (ctx) => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+  const claudeDir = join(ctx.home, ".claude");
+
+  const settingsFile = Bun.file(join(claudeDir, "settings.json"));
+  if (await settingsFile.exists()) {
+    try {
+      const settings = await settingsFile.json();
+      const pairs: Record<string, string> = {};
+      if (settings.permissions) {
+        for (const [key, val] of Object.entries(settings.permissions)) {
+          pairs[key] = String(val);
+        }
+      }
+      if (Object.keys(pairs).length) {
+        result["ai.claude.plugins"] = makeSection("ai.claude.plugins", { pairs });
+      }
+    } catch {}
+  }
+
+  try {
+    const skillsDir = join(claudeDir, "skills");
+    const glob = new Bun.Glob("*");
+    const items: { raw: string; columns: string[] }[] = [];
+    for await (const entry of glob.scan(skillsDir)) {
+      items.push({ raw: entry, columns: [entry] });
+    }
+    if (items.length) {
+      result["ai.claude.skills"] = makeSection("ai.claude.skills", { items });
+    }
+  } catch {}
+
+  const claudeMdFile = Bun.file(join(claudeDir, "CLAUDE.md"));
+  if (await claudeMdFile.exists()) {
+    const content = await claudeMdFile.text();
+    result["file:claude/CLAUDE.md"] = makeSection("file:claude/CLAUDE.md", {
+      content: content.trim(),
+    });
+  }
+
+  return result;
+};

package/src/collectors/cursor.ts

@@ -0,0 +1,30 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectCursor: Collector = async (ctx) => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+  const cursorDir = join(ctx.home, ".cursor");
+
+  const mcpFile = Bun.file(join(cursorDir, "mcp.json"));
+  if (await mcpFile.exists()) {
+    const content = await mcpFile.text();
+    result["ai.cursor.mcp"] = makeSection("ai.cursor.mcp", {
+      content: content.trim(),
+    });
+  }
+
+  try {
+    const skillsDir = join(cursorDir, "skills");
+    const glob = new Bun.Glob("*");
+    const items: { raw: string; columns: string[] }[] = [];
+    for await (const entry of glob.scan(skillsDir)) {
+      items.push({ raw: entry, columns: [entry] });
+    }
+    if (items.length) {
+      result["ai.cursor.skills"] = makeSection("ai.cursor.skills", { items });
+    }
+  } catch {}
+
+  return result;
+};

package/src/collectors/editors.ts

@@ -0,0 +1,27 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectEditors: Collector = async (ctx) => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+
+  const zedFile = Bun.file(join(ctx.home, ".config/zed/settings.json"));
+  if (await zedFile.exists()) {
+    const content = await zedFile.text();
+    result["editor.zed"] = makeSection("editor.zed", {
+      content: content.trim(),
+    });
+  }
+
+  const cursorSettingsFile = Bun.file(
+    join(ctx.home, "Library/Application Support/Cursor/User/settings.json")
+  );
+  if (await cursorSettingsFile.exists()) {
+    const content = await cursorSettingsFile.text();
+    result["editor.cursor"] = makeSection("editor.cursor", {
+      content: content.trim(),
+    });
+  }
+
+  return result;
+};

package/src/collectors/gemini.ts

@@ -0,0 +1,44 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectGemini: Collector = async (ctx) => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+  const geminiDir = join(ctx.home, ".gemini");
+
+  const settingsFile = Bun.file(join(geminiDir, "settings.json"));
+  if (await settingsFile.exists()) {
+    try {
+      const settings = await settingsFile.json();
+      const pairs: Record<string, string> = {};
+      for (const [key, val] of Object.entries(settings)) {
+        pairs[key] = typeof val === "object" ? JSON.stringify(val) : String(val);
+      }
+      if (Object.keys(pairs).length) {
+        result["ai.gemini.settings"] = makeSection("ai.gemini.settings", { pairs });
+      }
+    } catch {}
+  }
+
+  try {
+    const skillsDir = join(geminiDir, "skills");
+    const glob = new Bun.Glob("*");
+    const items: { raw: string; columns: string[] }[] = [];
+    for await (const entry of glob.scan(skillsDir)) {
+      items.push({ raw: entry, columns: [entry] });
+    }
+    if (items.length) {
+      result["ai.gemini.skills"] = makeSection("ai.gemini.skills", { items });
+    }
+  } catch {}
+
+  const geminiMdFile = Bun.file(join(geminiDir, "GEMINI.md"));
+  if (await geminiMdFile.exists()) {
+    const content = await geminiMdFile.text();
+    result["file:gemini/GEMINI.md"] = makeSection("file:gemini/GEMINI.md", {
+      content: content.trim(),
+    });
+  }
+
+  return result;
+};

package/src/collectors/gh.ts

@@ -0,0 +1,14 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectGh: Collector = async (ctx) => {
+  const configFile = Bun.file(join(ctx.home, ".config/gh/config.yml"));
+
+  if (!(await configFile.exists())) return {};
+
+  const content = await configFile.text();
+  return {
+    "gh.config": makeSection("gh.config", { content: content.trim() }),
+  };
+};

package/src/collectors/git.ts

@@ -0,0 +1,16 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectGit: Collector = async (ctx) => {
+  const gitconfigFile = Bun.file(join(ctx.home, ".gitconfig"));
+
+  if (!(await gitconfigFile.exists())) return {};
+
+  const content = await gitconfigFile.text();
+  return {
+    "file:git/gitconfig": makeSection("file:git/gitconfig", {
+      content: content.trim(),
+    }),
+  };
+};

package/src/collectors/homebrew.ts

@@ -0,0 +1,40 @@
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectHomebrew: Collector = async () => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+
+  try {
+    const formulaeOutput = await Bun.$`brew list --formula`.text();
+    const formulae = formulaeOutput
+      .trim()
+      .split("\n")
+      .map((f) => f.trim())
+      .filter(Boolean)
+      .sort();
+
+    if (formulae.length) {
+      result["apps.brew.formulae"] = makeSection("apps.brew.formulae", {
+        items: formulae.map((f) => ({ raw: f, columns: [f] })),
+      });
+    }
+  } catch {}
+
+  try {
+    const casksOutput = await Bun.$`brew list --cask`.text();
+    const casks = casksOutput
+      .trim()
+      .split("\n")
+      .map((c) => c.trim())
+      .filter(Boolean)
+      .sort();
+
+    if (casks.length) {
+      result["apps.brew.casks"] = makeSection("apps.brew.casks", {
+        items: casks.map((c) => ({ raw: c, columns: [c] })),
+      });
+    }
+  } catch {}
+
+  return result;
+};

package/src/collectors/meta.ts

@@ -0,0 +1,15 @@
+import { hostname } from "os";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectMeta: Collector = async () => {
+  const host = hostname();
+  const os = `${Bun.env.OSTYPE ?? (await Bun.$`uname -s`.text()).trim()} ${(await Bun.$`uname -m`.text()).trim()}`;
+  const date = new Date().toISOString().split("T")[0];
+
+  return {
+    meta: makeSection("meta", {
+      pairs: { host, os, date },
+    }),
+  };
+};

package/src/collectors/npm.ts

@@ -0,0 +1,18 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+import { redactNpmTokens } from "../utils/redact";
+
+export const collectNpm: Collector = async (ctx) => {
+  const npmrcPath = join(ctx.home, ".npmrc");
+  const file = Bun.file(npmrcPath);
+
+  if (!(await file.exists())) return {};
+
+  let content = await file.text();
+  if (ctx.redact) content = redactNpmTokens(content);
+
+  return {
+    "npm.config": makeSection("npm.config", { content: content.trim() }),
+  };
+};

package/src/collectors/ollama.ts

@@ -0,0 +1,26 @@
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectOllama: Collector = async () => {
+  try {
+    const output = await Bun.$`ollama list`.text();
+    const lines = output.trim().split("\n");
+
+    if (lines.length <= 1) return {};
+
+    const items = lines.slice(1).map((line) => {
+      const parts = line.split(/\s{2,}/).map((s) => s.trim()).filter(Boolean);
+      const [name, id, size, modified] = parts;
+      const raw = [name, size, modified].filter(Boolean).join(" | ");
+      return { raw, columns: [name, size, modified].filter(Boolean) };
+    }).filter((item) => item.columns.length > 0);
+
+    if (!items.length) return {};
+
+    return {
+      "ai.ollama.models": makeSection("ai.ollama.models", { items }),
+    };
+  } catch {
+    return {};
+  }
+};

package/src/collectors/shell.ts

@@ -0,0 +1,16 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectShell: Collector = async (ctx) => {
+  const zshrcFile = Bun.file(join(ctx.home, ".zshrc"));
+
+  if (!(await zshrcFile.exists())) return {};
+
+  const content = await zshrcFile.text();
+  return {
+    "file:shell/zshrc": makeSection("file:shell/zshrc", {
+      content: content.trim(),
+    }),
+  };
+};

package/src/collectors/ssh.ts

@@ -0,0 +1,61 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+import { redactSshConfig, redactIPs } from "../utils/redact";
+
+interface SshHost {
+  host: string;
+  hostname: string;
+  identityFile: string;
+}
+
+function parseSshConfig(content: string): SshHost[] {
+  const hosts: SshHost[] = [];
+  let current: Partial<SshHost> | null = null;
+
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+
+    const hostMatch = trimmed.match(/^Host\s+(.+)/i);
+    if (hostMatch) {
+      if (current?.host) hosts.push(current as SshHost);
+      current = { host: hostMatch[1].trim(), hostname: "", identityFile: "" };
+      continue;
+    }
+
+    if (!current) continue;
+
+    const hostnameMatch = trimmed.match(/^HostName\s+(.+)/i);
+    if (hostnameMatch) current.hostname = hostnameMatch[1].trim();
+
+    const identityMatch = trimmed.match(/^IdentityFile\s+(.+)/i);
+    if (identityMatch) current.identityFile = identityMatch[1].trim();
+  }
+
+  if (current?.host) hosts.push(current as SshHost);
+  return hosts;
+}
+
+export const collectSsh: Collector = async (ctx) => {
+  const configPath = join(ctx.home, ".ssh/config");
+  const file = Bun.file(configPath);
+
+  if (!(await file.exists())) return {};
+
+  const content = await file.text();
+  const hosts = parseSshConfig(content);
+
+  if (!hosts.length) return {};
+
+  const items = hosts.map((h) => {
+    const hn = ctx.redact ? "[REDACTED]" : h.hostname;
+    const id = ctx.redact ? "[REDACTED]" : h.identityFile;
+    const raw = `${h.host} | ${hn} | ${id}`;
+    return { raw, columns: [h.host, hn, id] };
+  });
+
+  return {
+    "ssh.hosts": makeSection("ssh.hosts", { items }),
+  };
+};

package/src/collectors/terminal.ts

@@ -0,0 +1,18 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectTerminal: Collector = async (ctx) => {
+  const p10kFile = Bun.file(join(ctx.home, ".p10k.zsh"));
+
+  if (!(await p10kFile.exists())) return {};
+
+  const content = await p10kFile.text();
+  const lineCount = content.split("\n").length;
+
+  return {
+    "terminal.p10k": makeSection("terminal.p10k", {
+      pairs: { exists: "true", lines: String(lineCount) },
+    }),
+  };
+};

package/src/collectors/types.ts

@@ -0,0 +1,26 @@
+import type { DotfSection } from "@dotformat/core";
+
+export interface CollectorContext {
+  redact: boolean;
+  home: string;
+}
+
+export type CollectorResult = Record<string, DotfSection>;
+
+export type Collector = (ctx: CollectorContext) => Promise<CollectorResult>;
+
+export function makeSection(
+  name: string,
+  opts: {
+    pairs?: Record<string, string>;
+    items?: { raw: string; columns: string[] }[];
+    content?: string | null;
+  } = {}
+): DotfSection {
+  return {
+    name,
+    pairs: opts.pairs ?? {},
+    items: opts.items ?? [],
+    content: opts.content ?? null,
+  };
+}

package/src/collectors/windsurf.ts

@@ -0,0 +1,30 @@
+import { join } from "path";
+import type { Collector } from "./types";
+import { makeSection } from "./types";
+
+export const collectWindsurf: Collector = async (ctx) => {
+  const result: Record<string, ReturnType<typeof makeSection>> = {};
+  const windsurfDir = join(ctx.home, ".codeium/windsurf");
+
+  const mcpFile = Bun.file(join(windsurfDir, "mcp_config.json"));
+  if (await mcpFile.exists()) {
+    const content = await mcpFile.text();
+    result["ai.windsurf.mcp"] = makeSection("ai.windsurf.mcp", {
+      content: content.trim(),
+    });
+  }
+
+  try {
+    const skillsDir = join(windsurfDir, "skills");
+    const glob = new Bun.Glob("*");
+    const items: { raw: string; columns: string[] }[] = [];
+    for await (const entry of glob.scan(skillsDir)) {
+      items.push({ raw: entry, columns: [entry] });
+    }
+    if (items.length) {
+      result["ai.windsurf.skills"] = makeSection("ai.windsurf.skills", { items });
+    }
+  } catch {}
+
+  return result;
+};

package/src/commands/collect.ts

@@ -0,0 +1,83 @@
+import { hostname } from "os";
+import { join } from "path";
+import { stringify } from "@dotformat/core";
+import type { DotfDocument } from "@dotformat/core";
+import type { CollectorContext, CollectorResult } from "../collectors/types";
+import { collectMeta } from "../collectors/meta";
+import { collectClaude } from "../collectors/claude";
+import { collectCursor } from "../collectors/cursor";
+import { collectGemini } from "../collectors/gemini";
+import { collectWindsurf } from "../collectors/windsurf";
+import { collectOllama } from "../collectors/ollama";
+import { collectShell } from "../collectors/shell";
+import { collectGit } from "../collectors/git";
+import { collectGh } from "../collectors/gh";
+import { collectEditors } from "../collectors/editors";
+import { collectTerminal } from "../collectors/terminal";
+import { collectSsh } from "../collectors/ssh";
+import { collectNpm } from "../collectors/npm";
+import { collectBunConfig } from "../collectors/bun-config";
+import { collectApps } from "../collectors/apps";
+import { collectHomebrew } from "../collectors/homebrew";
+
+const collectors = [
+  collectMeta,
+  collectClaude,
+  collectCursor,
+  collectGemini,
+  collectWindsurf,
+  collectOllama,
+  collectShell,
+  collectGit,
+  collectGh,
+  collectEditors,
+  collectTerminal,
+  collectSsh,
+  collectNpm,
+  collectBunConfig,
+  collectApps,
+  collectHomebrew,
+];
+
+function parseArgs(args: string[]) {
+  let redact = true;
+  let outputDir: string | null = null;
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--no-redact") redact = false;
+    if (args[i] === "-o" && args[i + 1]) outputDir = args[++i];
+  }
+
+  return { redact, outputDir };
+}
+
+export async function collect(args: string[]) {
+  const { redact, outputDir } = parseArgs(args);
+
+  const repoRoot = join(import.meta.dir, "../..");
+  const resolvedOutput =
+    outputDir ?? join(repoRoot, "reports");
+
+  await Bun.$`mkdir -p ${resolvedOutput}`.quiet();
+
+  const ctx: CollectorContext = {
+    redact,
+    home: Bun.env.HOME ?? "/tmp",
+  };
+
+  const sections: CollectorResult = {};
+
+  for (const collector of collectors) {
+    const result = await collector(ctx);
+    Object.assign(sections, result);
+  }
+
+  const doc: DotfDocument = { sections };
+  const output = stringify(doc);
+
+  const filename = `${hostname()}.dotf`;
+  const filepath = join(resolvedOutput, filename);
+  await Bun.write(filepath, output);
+
+  console.log(`Report saved to: ${filepath}`);
+}

package/src/commands/compare.ts

@@ -0,0 +1,50 @@
+import { join } from "path";
+import { parse, compare, formatDiff } from "@dotformat/core";
+
+export async function compareCli(args: string[]) {
+  const reportsDir = join(import.meta.dir, "../../reports");
+
+  let files: string[];
+
+  if (args.length >= 2) {
+    files = args.slice(0, 2);
+  } else {
+    const glob = new Bun.Glob("*.dotf");
+    const entries: { path: string; mtime: number }[] = [];
+
+    for await (const path of glob.scan(reportsDir)) {
+      const stat = await Bun.file(join(reportsDir, path)).stat();
+      entries.push({ path: join(reportsDir, path), mtime: stat?.mtimeMs ?? 0 });
+    }
+
+    entries.sort((a, b) => b.mtime - a.mtime);
+
+    if (entries.length < 2) {
+      console.log("Need at least 2 .dotf reports in reports/ to compare.");
+      console.log("Usage: dotfiles compare [file1] [file2]");
+      return;
+    }
+
+    files = [entries[0].path, entries[1].path];
+  }
+
+  const [leftContent, rightContent] = await Promise.all([
+    Bun.file(files[0]).text(),
+    Bun.file(files[1]).text(),
+  ]);
+
+  const left = parse(leftContent);
+  const right = parse(rightContent);
+  const diff = compare(left, right);
+
+  const leftLabel = files[0].split("/").pop()?.replace(".dotf", "") ?? "left";
+  const rightLabel = files[1].split("/").pop()?.replace(".dotf", "") ?? "right";
+
+  const output = formatDiff(diff, { leftLabel, rightLabel, color: true });
+
+  if (!output.trim()) {
+    console.log("No differences found.");
+  } else {
+    console.log(output);
+  }
+}

package/src/commands/list.ts

@@ -0,0 +1,55 @@
+import { join } from "path";
+import { parse, stringify } from "@dotformat/core";
+import type { DotfDocument } from "@dotformat/core";
+
+function fuzzyMatch(query: string, sectionName: string): boolean {
+  const q = query.toLowerCase();
+  const s = sectionName.toLowerCase();
+  return s.includes(q) || s.split(".").some((part) => part.includes(q));
+}
+
+export async function list(args: string[]) {
+  if (!args.length) {
+    console.log("Usage: dotfiles list <section>");
+    console.log('Example: dotfiles list brew');
+    return;
+  }
+
+  const query = args[0];
+  const reportsDir = join(import.meta.dir, "../../reports");
+
+  const glob = new Bun.Glob("*.dotf");
+  const entries: { path: string; mtime: number }[] = [];
+
+  for await (const path of glob.scan(reportsDir)) {
+    const stat = await Bun.file(join(reportsDir, path)).stat();
+    entries.push({ path: join(reportsDir, path), mtime: stat?.mtimeMs ?? 0 });
+  }
+
+  entries.sort((a, b) => b.mtime - a.mtime);
+
+  if (!entries.length) {
+    console.log("No .dotf reports found. Run 'dotfiles collect' first.");
+    return;
+  }
+
+  const content = await Bun.file(entries[0].path).text();
+  const doc = parse(content);
+
+  const matches = Object.keys(doc.sections).filter((name) =>
+    fuzzyMatch(query, name)
+  );
+
+  if (!matches.length) {
+    console.log(`No sections matching "${query}".`);
+    console.log("Available sections:", Object.keys(doc.sections).join(", "));
+    return;
+  }
+
+  for (const name of matches) {
+    const sectionDoc: DotfDocument = {
+      sections: { [name]: doc.sections[name] },
+    };
+    console.log(stringify(sectionDoc));
+  }
+}

package/src/utils/redact.ts

@@ -0,0 +1,22 @@
+const IP_PATTERN = /\b\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}\b/g;
+const AUTH_TOKEN_PATTERN = /(_authToken=).+/g;
+const SSH_HOSTNAME_PATTERN = /(HostName\s+).+/g;
+const SSH_IDENTITY_PATTERN = /(IdentityFile\s+).+/g;
+
+export function redactIPs(text: string): string {
+  return text.replace(IP_PATTERN, "[REDACTED]");
+}
+
+export function redactNpmTokens(text: string): string {
+  return text.replace(AUTH_TOKEN_PATTERN, "$1[REDACTED]");
+}
+
+export function redactSshConfig(text: string): string {
+  return text
+    .replace(SSH_HOSTNAME_PATTERN, "$1[REDACTED]")
+    .replace(SSH_IDENTITY_PATTERN, "$1[REDACTED]");
+}
+
+export function redactAll(text: string): string {
+  return redactIPs(redactNpmTokens(redactSshConfig(text)));
+}

package/bin/dotfiles.js

@@ -1,5 +0,0 @@
-#!/usr/bin/env node
-const { execFileSync } = require("child_process");
-const { join } = require("path");
-
-execFileSync("bash", [join(__dirname, "..", "setup", "collect-machine-config.sh")], { stdio: "inherit" });

package/setup/collect-machine-config.sh

@@ -1,188 +0,0 @@
-#!/bin/bash
-# Collects AI tool configs and system info from any machine.
-# Run on work Mac, then copy the output file back to compare.
-#
-# Usage:
-#   bash collect-machine-config.sh           # outputs to ./reports/ if in repo, else ~/
-#   bash collect-machine-config.sh -o /path  # custom output directory
-
-SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
-REPO_ROOT="$(dirname "$SCRIPT_DIR")"
-HOSTNAME="$(hostname -s)"
-FILENAME="dotfiles-report-${HOSTNAME}.md"
-
-OUTPUT_DIR=""
-while getopts "o:" opt; do
-  case $opt in
-    o) OUTPUT_DIR="$OPTARG" ;;
-    *) ;;
-  esac
-done
-
-if [ -n "$OUTPUT_DIR" ]; then
-  mkdir -p "$OUTPUT_DIR"
-elif [ -d "$REPO_ROOT/reports" ] || [ -d "$REPO_ROOT/.git" ]; then
-  OUTPUT_DIR="$REPO_ROOT/reports"
-  mkdir -p "$OUTPUT_DIR"
-else
-  OUTPUT_DIR="$HOME"
-fi
-
-REPORT="$OUTPUT_DIR/$FILENAME"
-
-{
-  echo "# Machine Config Report"
-  echo "- **Host:** $HOSTNAME"
-  echo "- **OS:** $(uname -s) $(uname -m)"
-  echo "- **Date:** $(date +%Y-%m-%d)"
-  echo ""
-
-  echo "## Claude Code"
-  echo "### settings.json"
-  echo '```json'
-  cat ~/.claude/settings.json 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo "### CLAUDE.md"
-  echo '```markdown'
-  cat ~/.claude/CLAUDE.md 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Cursor"
-  echo "### mcp.json"
-  echo '```json'
-  cat ~/.cursor/mcp.json 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo "### Skills"
-  echo '```'
-  ls ~/.cursor/skills/ 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Gemini CLI"
-  echo "### settings.json"
-  echo '```json'
-  cat ~/.gemini/settings.json 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo "### GEMINI.md"
-  echo '```markdown'
-  cat ~/.gemini/GEMINI.md 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo "### Skills"
-  echo '```'
-  ls ~/.gemini/skills/ 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Windsurf"
-  echo "### mcp_config.json"
-  echo '```json'
-  cat ~/.codeium/windsurf/mcp_config.json 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo "### Skills"
-  echo '```'
-  ls ~/.codeium/windsurf/skills/ 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Shell"
-  echo "### .zshrc"
-  echo '```bash'
-  cat ~/.zshrc 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Git"
-  echo "### .gitconfig"
-  echo '```ini'
-  cat ~/.gitconfig 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Editors"
-  echo "### Zed settings.json"
-  echo '```json'
-  cat ~/.config/zed/settings.json 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo "### Cursor editor settings"
-  echo '```json'
-  cat ~/Library/Application\ Support/Cursor/User/settings.json 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Terminal"
-  echo "### p10k theme"
-  echo '```'
-  [ -f ~/.p10k.zsh ] && echo "(exists, $(wc -l < ~/.p10k.zsh) lines)" || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## SSH Config"
-  echo '```'
-  if [ -f ~/.ssh/config ]; then
-    # Redact IP addresses and key paths for safety
-    sed 's/HostName .*/HostName [REDACTED]/; s/IdentityFile .*/IdentityFile [REDACTED]/' ~/.ssh/config
-  else
-    echo "(not found)"
-  fi
-  echo '```'
-  echo ""
-
-  echo "## GitHub CLI"
-  echo '```yaml'
-  cat ~/.config/gh/config.yml 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## npm config (.npmrc)"
-  echo '```'
-  if [ -f ~/.npmrc ]; then
-    # Redact auth tokens
-    sed 's/_authToken=.*/_authToken=[REDACTED]/' ~/.npmrc
-  else
-    echo "(not found)"
-  fi
-  echo '```'
-  echo ""
-
-  echo "## Bun config (bunfig.toml)"
-  echo '```toml'
-  cat ~/.bunfig.toml 2>/dev/null || echo "(not found)"
-  echo '```'
-  echo ""
-
-  echo "## Raycast"
-  echo '```'
-  [ -d "/Applications/Raycast.app" ] && echo "(installed)" || echo "(not installed)"
-  echo '```'
-  echo ""
-
-  echo "## AltTab"
-  echo '```'
-  if [ -d "/Applications/AltTab.app" ]; then
-    echo "(installed)"
-    defaults read com.lwouis.alt-tab-macos 2>/dev/null | head -30 || echo "(no preferences found)"
-  else
-    echo "(not installed)"
-  fi
-  echo '```'
-  echo ""
-
-  echo "## macOS Apps (/Applications)"
-  echo '```'
-  ls /Applications/ 2>/dev/null | sort || echo "(unable to list)"
-  echo '```'
-  echo ""
-
-  echo "## Homebrew"
-  echo '```'
-  brew list --formula 2>/dev/null | sort || echo "(brew not found)"
-  echo '```'
-  echo "### Casks"
-  echo '```'
-  brew list --cask 2>/dev/null | sort || echo "(brew not found)"
-  echo '```'
-
-} > "$REPORT"
-
-echo "Report saved to: $REPORT"