md4ai 0.1.0

package/dist/index.bundled.js

@@ -0,0 +1,1353 @@
+#!/usr/bin/env node
+
+// dist/index.js
+import { Command } from "commander";
+
+// ../packages/shared/dist/constants.js
+var SUPABASE_URL = "https://gkrfwmwlfnixeffhwwju.supabase.co";
+var ROOT_FILES = [
+  "CLAUDE.md",
+  ".claude/settings.json",
+  ".claude/settings.local.json"
+];
+var GLOBAL_ROOT_FILES = [
+  "~/.claude/CLAUDE.md",
+  "~/.claude/settings.json",
+  "~/.claude/settings.local.json"
+];
+var STALE_THRESHOLD_DAYS = 90;
+var CONFIG_DIR = ".md4ai";
+var CREDENTIALS_FILE = "credentials.json";
+var STATE_FILE = "state.json";
+
+// ../packages/shared/dist/supabase.js
+import { createClient } from "@supabase/supabase-js";
+function createSupabaseClient(anonKey, accessToken) {
+  const options = accessToken ? { global: { headers: { Authorization: `Bearer ${accessToken}` } } } : {};
+  return createClient(SUPABASE_URL, anonKey, options);
+}
+
+// dist/config.js
+import { readFile, writeFile, mkdir, chmod } from "node:fs/promises";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { existsSync } from "node:fs";
+var configPath = join(homedir(), CONFIG_DIR);
+var credentialsPath = join(configPath, CREDENTIALS_FILE);
+var statePath = join(configPath, STATE_FILE);
+async function ensureConfigDir() {
+  if (!existsSync(configPath)) {
+    await mkdir(configPath, { recursive: true });
+    await chmod(configPath, 448);
+  }
+}
+async function saveCredentials(creds) {
+  await ensureConfigDir();
+  await writeFile(credentialsPath, JSON.stringify(creds, null, 2), "utf-8");
+  await chmod(credentialsPath, 384);
+}
+async function loadCredentials() {
+  try {
+    const data = await readFile(credentialsPath, "utf-8");
+    const parsed = JSON.parse(data);
+    if (!parsed.accessToken)
+      return null;
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+async function clearCredentials() {
+  try {
+    await writeFile(credentialsPath, "{}", "utf-8");
+  } catch {
+  }
+}
+async function saveState(state) {
+  await ensureConfigDir();
+  const existing = await loadState();
+  const merged = { ...existing, ...state };
+  await writeFile(statePath, JSON.stringify(merged, null, 2), "utf-8");
+}
+async function loadState() {
+  try {
+    const data = await readFile(statePath, "utf-8");
+    return JSON.parse(data);
+  } catch {
+    return { lastFolderId: null, lastDeviceName: null, lastSyncAt: null };
+  }
+}
+function getAnonKey() {
+  const key = process.env.MD4AI_SUPABASE_ANON_KEY;
+  if (!key) {
+    throw new Error("MD4AI_SUPABASE_ANON_KEY environment variable not set.\nSet it in your shell profile or .env file.");
+  }
+  return key;
+}
+
+// dist/commands/login.js
+import chalk from "chalk";
+import { input, password } from "@inquirer/prompts";
+async function loginCommand() {
+  console.log(chalk.blue("MD4AI Login\n"));
+  const email = await input({ message: "Email:" });
+  const pwd = await password({ message: "Password:" });
+  const anonKey = getAnonKey();
+  const supabase = createSupabaseClient(anonKey);
+  const { data, error } = await supabase.auth.signInWithPassword({
+    email,
+    password: pwd
+  });
+  if (error) {
+    console.error(chalk.red(`Login failed: ${error.message}`));
+    process.exit(1);
+  }
+  await saveCredentials({
+    accessToken: data.session.access_token,
+    refreshToken: data.session.refresh_token,
+    expiresAt: Date.now() + data.session.expires_in * 1e3,
+    userId: data.user.id,
+    email: data.user.email ?? email
+  });
+  console.log(chalk.green(`
+Logged in as ${data.user.email}`));
+}
+
+// dist/commands/logout.js
+import chalk2 from "chalk";
+async function logoutCommand() {
+  await clearCredentials();
+  console.log(chalk2.green("Logged out successfully."));
+}
+
+// dist/commands/status.js
+import chalk3 from "chalk";
+async function statusCommand() {
+  const creds = await loadCredentials();
+  if (!creds?.accessToken) {
+    console.log(chalk3.yellow("Not logged in. Run: md4ai login"));
+    return;
+  }
+  console.log(chalk3.blue("MD4AI Status\n"));
+  console.log(`  User:    ${creds.email}`);
+  console.log(`  Expires: ${new Date(creds.expiresAt).toLocaleString()}`);
+  try {
+    const anonKey = getAnonKey();
+    const supabase = createSupabaseClient(anonKey, creds.accessToken);
+    const { count: folderCount } = await supabase.from("claude_folders").select("*", { count: "exact", head: true });
+    const { count: deviceCount } = await supabase.from("device_paths").select("*", { count: "exact", head: true });
+    console.log(`  Folders: ${folderCount ?? 0}`);
+    console.log(`  Devices: ${deviceCount ?? 0}`);
+    const state = await loadState();
+    console.log(`  Last sync: ${state.lastSyncAt ?? "never"}`);
+  } catch {
+    console.log(chalk3.yellow("  (Could not fetch remote data)"));
+  }
+}
+
+// dist/auth.js
+import chalk4 from "chalk";
+async function getAuthenticatedClient() {
+  const creds = await loadCredentials();
+  if (!creds?.accessToken) {
+    console.error(chalk4.red("Not logged in. Run: md4ai login"));
+    process.exit(1);
+  }
+  if (Date.now() > creds.expiresAt) {
+    console.error(chalk4.red("Session expired. Run: md4ai login"));
+    process.exit(1);
+  }
+  const anonKey = getAnonKey();
+  const supabase = createSupabaseClient(anonKey, creds.accessToken);
+  return { supabase, userId: creds.userId };
+}
+
+// dist/commands/add-folder.js
+import chalk5 from "chalk";
+import { input as input2, select } from "@inquirer/prompts";
+async function addFolderCommand() {
+  const { supabase, userId } = await getAuthenticatedClient();
+  const name = await input2({ message: "Folder name:" });
+  const description = await input2({ message: "Description (optional):" });
+  const { data: teams } = await supabase.from("team_members").select("team_id, teams(id, name)").eq("user_id", userId);
+  const { data: ownedTeams } = await supabase.from("teams").select("id, name").eq("created_by", userId);
+  const allTeams = /* @__PURE__ */ new Map();
+  for (const t of ownedTeams ?? []) {
+    allTeams.set(t.id, t.name);
+  }
+  for (const t of teams ?? []) {
+    const team = t.teams;
+    if (team)
+      allTeams.set(team.id, team.name);
+  }
+  let teamId = null;
+  if (allTeams.size > 0) {
+    const choices = [
+      { name: "Personal (only you)", value: "__personal__" },
+      ...Array.from(allTeams.entries()).map(([id, teamName]) => ({
+        name: teamName,
+        value: id
+      }))
+    ];
+    const selected = await select({
+      message: "Assign to a team?",
+      choices
+    });
+    teamId = selected === "__personal__" ? null : selected;
+  }
+  const { data, error } = await supabase.from("claude_folders").insert({
+    user_id: userId,
+    name,
+    description: description || null,
+    team_id: teamId
+  }).select().single();
+  if (error) {
+    console.error(chalk5.red(`Failed to create folder: ${error.message}`));
+    process.exit(1);
+  }
+  const teamLabel = teamId ? `(team: ${allTeams.get(teamId)})` : "(personal)";
+  console.log(chalk5.green(`
+Folder "${name}" created ${teamLabel} (${data.id})`));
+}
+
+// dist/commands/add-device.js
+import { resolve } from "node:path";
+import { hostname, platform } from "node:os";
+import chalk6 from "chalk";
+import { input as input3, select as select2 } from "@inquirer/prompts";
+function detectOs() {
+  const p = platform();
+  if (p === "win32")
+    return "windows";
+  if (p === "darwin")
+    return "macos";
+  if (p === "linux")
+    return "linux";
+  return "other";
+}
+function suggestDeviceName() {
+  const os = detectOs();
+  const host = hostname().split(".")[0];
+  const osLabel = os.charAt(0).toUpperCase() + os.slice(1);
+  return `${host}-${osLabel}`;
+}
+async function addDeviceCommand() {
+  const { supabase, userId } = await getAuthenticatedClient();
+  const cwd = resolve(process.cwd());
+  console.log(chalk6.blue.bold("\n\u{1F4C2} Where is this Claude project?\n"));
+  const localPath = await input3({
+    message: "Local project path:",
+    default: cwd
+  });
+  const { data: folders, error: foldersErr } = await supabase.from("claude_folders").select("id, name").order("name");
+  if (foldersErr || !folders?.length) {
+    console.error(chalk6.red("No folders found. Run: md4ai add-folder"));
+    process.exit(1);
+  }
+  const folderId = await select2({
+    message: "Select folder:",
+    choices: folders.map((f) => ({ name: f.name, value: f.id }))
+  });
+  const suggested = suggestDeviceName();
+  const deviceName = await input3({
+    message: "Device name:",
+    default: suggested
+  });
+  const osType = await select2({
+    message: "OS type:",
+    choices: [
+      { name: "Windows", value: "windows" },
+      { name: "macOS", value: "macos" },
+      { name: "Ubuntu", value: "ubuntu" },
+      { name: "Linux", value: "linux" },
+      { name: "Other", value: "other" }
+    ],
+    default: detectOs()
+  });
+  const description = await input3({ message: "Description (optional):" });
+  const { error } = await supabase.from("device_paths").insert({
+    user_id: userId,
+    folder_id: folderId,
+    device_name: deviceName,
+    os_type: osType,
+    path: localPath,
+    description: description || null
+  });
+  if (error) {
+    console.error(chalk6.red(`Failed to add device: ${error.message}`));
+    process.exit(1);
+  }
+  console.log(chalk6.green(`
+Device "${deviceName}" added to folder.`));
+}
+
+// dist/commands/list-devices.js
+import chalk7 from "chalk";
+async function listDevicesCommand() {
+  const { supabase } = await getAuthenticatedClient();
+  const { data: devices, error } = await supabase.from("device_paths").select(`
+      id, device_name, os_type, path, last_synced, description,
+      claude_folders!inner ( name )
+    `).order("device_name");
+  if (error) {
+    console.error(chalk7.red(`Failed to list devices: ${error.message}`));
+    process.exit(1);
+  }
+  if (!devices?.length) {
+    console.log(chalk7.yellow("No devices found. Run: md4ai add-device"));
+    return;
+  }
+  const grouped = /* @__PURE__ */ new Map();
+  for (const d of devices) {
+    const list = grouped.get(d.device_name) ?? [];
+    list.push(d);
+    grouped.set(d.device_name, list);
+  }
+  for (const [deviceName, entries] of grouped) {
+    const first = entries[0];
+    console.log(chalk7.bold(`
+${deviceName}`) + chalk7.dim(` (${first.os_type})`));
+    for (const entry of entries) {
+      const folderName = entry.claude_folders?.name ?? "unknown";
+      const synced = entry.last_synced ? new Date(entry.last_synced).toLocaleString() : "never";
+      console.log(`  ${chalk7.cyan(folderName)} \u2192 ${entry.path}`);
+      console.log(`    Last synced: ${synced}`);
+    }
+  }
+}
+
+// dist/commands/map.js
+import { resolve as resolve3 } from "node:path";
+import { writeFile as writeFile2, mkdir as mkdir2 } from "node:fs/promises";
+import { existsSync as existsSync5 } from "node:fs";
+import chalk8 from "chalk";
+
+// dist/scanner/index.js
+import { readdir } from "node:fs/promises";
+import { join as join6, relative } from "node:path";
+import { existsSync as existsSync4 } from "node:fs";
+import { homedir as homedir4 } from "node:os";
+import { createHash } from "node:crypto";
+
+// dist/scanner/file-parser.js
+import { readFile as readFile2 } from "node:fs/promises";
+import { existsSync as existsSync2 } from "node:fs";
+import { resolve as resolve2, dirname, join as join2 } from "node:path";
+import { homedir as homedir2 } from "node:os";
+var FILE_EXT_PATTERN = "md|json|ya?ml|ts|js|sh|py|bash";
+async function parseFileReferences(filePath, projectRoot) {
+  const refs = [];
+  const content = await readFile2(filePath, "utf-8");
+  const relPath = filePath.startsWith(projectRoot) ? filePath.slice(projectRoot.length + 1) : filePath;
+  const markdownLinkPattern = /\[.*?\]\(([^)]+)\)/g;
+  const bareFilePattern = new RegExp(`(?:^|\\s)((?:\\.\\.?\\/)?[\\w./-]+\\.(?:${FILE_EXT_PATTERN}))\\b`, "gm");
+  const claudeDirQuotedPattern = new RegExp(`"\\$CLAUDE_PROJECT_DIR"\\/([\\w./-]+\\.(?:${FILE_EXT_PATTERN}))`, "g");
+  const claudeDirUnquotedPattern = new RegExp(`\\$CLAUDE_PROJECT_DIR\\/([\\w./-]+\\.(?:${FILE_EXT_PATTERN}))`, "g");
+  const patterns = [
+    markdownLinkPattern,
+    bareFilePattern,
+    claudeDirQuotedPattern,
+    claudeDirUnquotedPattern
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const target = match[1];
+      if (!target || target.startsWith("http") || target.startsWith("#"))
+        continue;
+      const resolved = resolveTarget(target, filePath, projectRoot);
+      if (resolved && existsSync2(resolved)) {
+        addRef(refs, relPath, resolved, projectRoot);
+      }
+    }
+  }
+  if (filePath.endsWith(".json")) {
+    parseJsonPathReferences(content, relPath, projectRoot, refs);
+  }
+  const seen = /* @__PURE__ */ new Set();
+  return refs.filter((r) => {
+    const key = `${r.from}->${r.to}`;
+    if (seen.has(key))
+      return false;
+    seen.add(key);
+    return true;
+  });
+}
+function resolveTarget(target, sourceFilePath, projectRoot) {
+  if (target.startsWith("~")) {
+    return target.replace("~", homedir2());
+  }
+  if (target.startsWith("/")) {
+    return target;
+  }
+  if (target.startsWith(".claude/") || target.startsWith("docs/")) {
+    return join2(projectRoot, target);
+  }
+  return resolve2(dirname(sourceFilePath), target);
+}
+function addRef(refs, fromRel, resolvedAbsolute, projectRoot) {
+  const targetRel = resolvedAbsolute.startsWith(projectRoot) ? resolvedAbsolute.slice(projectRoot.length + 1) : resolvedAbsolute;
+  if (targetRel !== fromRel) {
+    refs.push({ from: fromRel, to: targetRel });
+  }
+}
+function parseJsonPathReferences(content, fromRel, projectRoot, refs) {
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return;
+  }
+  walkJsonValues(parsed, (value) => {
+    const quotedPattern = new RegExp(`"\\$CLAUDE_PROJECT_DIR"\\/([\\w./-]+\\.(?:${FILE_EXT_PATTERN}))`, "g");
+    const unquotedPattern = new RegExp(`\\$CLAUDE_PROJECT_DIR\\/([\\w./-]+\\.(?:${FILE_EXT_PATTERN}))`, "g");
+    for (const pattern of [quotedPattern, unquotedPattern]) {
+      let match;
+      while ((match = pattern.exec(value)) !== null) {
+        const relTarget = match[1];
+        const resolved = join2(projectRoot, relTarget);
+        if (existsSync2(resolved)) {
+          addRef(refs, fromRel, resolved, projectRoot);
+        }
+      }
+    }
+    const barePattern = new RegExp(`(?:^|[\\s":/])((?:\\.?\\.?\\/)?[\\w./-]+\\.(?:${FILE_EXT_PATTERN}))(?:[\\s"']|$)`, "g");
+    let bareMatch;
+    while ((bareMatch = barePattern.exec(value)) !== null) {
+      const target = bareMatch[1];
+      if (!target || target.startsWith("http"))
+        continue;
+      const resolved = join2(projectRoot, target);
+      if (existsSync2(resolved)) {
+        addRef(refs, fromRel, resolved, projectRoot);
+      }
+    }
+  });
+}
+function walkJsonValues(obj, callback) {
+  if (typeof obj === "string") {
+    callback(obj);
+  } else if (Array.isArray(obj)) {
+    for (const item of obj) {
+      walkJsonValues(item, callback);
+    }
+  } else if (obj !== null && typeof obj === "object") {
+    for (const value of Object.values(obj)) {
+      walkJsonValues(value, callback);
+    }
+  }
+}
+function classifyFileType(filePath) {
+  const lower = filePath.toLowerCase();
+  if (lower === "claude.md" || lower.endsWith("/claude.md"))
+    return "root";
+  if (lower.includes("settings.json") || lower.includes("settings.local.json"))
+    return "config";
+  if (lower.includes("skill") || lower.includes("plugin"))
+    return "skill";
+  if (lower.includes("memory") || lower.includes("memory.md"))
+    return "memory";
+  if (lower.includes("plan") || lower.includes("docs/plans"))
+    return "plan";
+  return "other";
+}
+
+// dist/scanner/git-dates.js
+import { execFileSync } from "node:child_process";
+import { statSync } from "node:fs";
+function getGitLastModified(filePath, cwd) {
+  try {
+    const result = execFileSync("git", ["log", "-1", "--format=%cI", "--", filePath], { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+    return result || null;
+  } catch {
+    try {
+      return statSync(filePath).mtime.toISOString();
+    } catch {
+      return null;
+    }
+  }
+}
+function getGitCreationDate(filePath, cwd) {
+  try {
+    const result = execFileSync("git", ["log", "--diff-filter=A", "--format=%cI", "--", filePath], { cwd, encoding: "utf-8", timeout: 5e3 }).trim();
+    return result || null;
+  } catch {
+    try {
+      return statSync(filePath).birthtime.toISOString();
+    } catch {
+      return null;
+    }
+  }
+}
+
+// dist/scanner/graph-builder.js
+import { statSync as statSync2 } from "node:fs";
+import { join as join3 } from "node:path";
+function buildGraph(files, references, projectRoot) {
+  const nodeMap = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const fullPath = file.startsWith("/") ? file : join3(projectRoot, file);
+    let sizeBytes = 0;
+    try {
+      sizeBytes = statSync2(fullPath).size;
+    } catch {
+    }
+    nodeMap.set(file, {
+      id: sanitiseId(file),
+      label: file.split("/").pop() ?? file,
+      filePath: file,
+      type: classifyFileType(file),
+      lastModified: getGitLastModified(fullPath, projectRoot),
+      createdAt: getGitCreationDate(fullPath, projectRoot),
+      sizeBytes
+    });
+  }
+  for (const ref of references) {
+    if (!nodeMap.has(ref.to)) {
+      const fullPath = ref.to.startsWith("/") ? ref.to : join3(projectRoot, ref.to);
+      let sizeBytes = 0;
+      try {
+        sizeBytes = statSync2(fullPath).size;
+      } catch {
+      }
+      nodeMap.set(ref.to, {
+        id: sanitiseId(ref.to),
+        label: ref.to.split("/").pop() ?? ref.to,
+        filePath: ref.to,
+        type: classifyFileType(ref.to),
+        lastModified: getGitLastModified(fullPath, projectRoot),
+        createdAt: getGitCreationDate(fullPath, projectRoot),
+        sizeBytes
+      });
+    }
+  }
+  const nodes = Array.from(nodeMap.values());
+  const edges = references.map((ref) => ({
+    from: sanitiseId(ref.from),
+    to: sanitiseId(ref.to),
+    label: ref.label
+  }));
+  const mermaidLines = ["graph TD"];
+  for (const node of nodes) {
+    const escapedLabel = node.label.replace(/"/g, "#quot;");
+    const shape = node.type === "root" ? `[["${escapedLabel}"]]` : node.type === "config" ? `[("${escapedLabel}")]` : `["${escapedLabel}"]`;
+    mermaidLines.push(`  ${node.id}${shape}`);
+  }
+  for (const edge of edges) {
+    const label = edge.label ? `|${edge.label}|` : "";
+    mermaidLines.push(`  ${edge.from} -->${label} ${edge.to}`);
+  }
+  const rootNodes = nodes.filter((n) => n.type === "root");
+  if (rootNodes.length) {
+    for (const rn of rootNodes) {
+      mermaidLines.push(`  style ${rn.id} fill:#f9f,stroke:#333`);
+    }
+  }
+  return {
+    mermaid: mermaidLines.join("\n"),
+    nodes,
+    edges
+  };
+}
+function sanitiseId(path) {
+  return path.replace(/[^a-zA-Z0-9]/g, "_").replace(/_+/g, "_").replace(/^_|_$/g, "").slice(0, 64);
+}
+
+// dist/scanner/orphan-detector.js
+import { statSync as statSync3 } from "node:fs";
+import { join as join4 } from "node:path";
+function detectOrphans(allFiles, references, rootFiles, projectRoot) {
+  const reachable = new Set(rootFiles);
+  const refMap = /* @__PURE__ */ new Map();
+  for (const ref of references) {
+    const targets = refMap.get(ref.from) ?? [];
+    targets.push(ref.to);
+    refMap.set(ref.from, targets);
+  }
+  const queue = [...rootFiles];
+  while (queue.length > 0) {
+    const current = queue.pop();
+    const targets = refMap.get(current) ?? [];
+    for (const target of targets) {
+      if (!reachable.has(target)) {
+        reachable.add(target);
+        queue.push(target);
+      }
+    }
+  }
+  return allFiles.filter((f) => !reachable.has(f)).map((f) => {
+    const fullPath = join4(projectRoot, f);
+    let sizeBytes = 0;
+    try {
+      sizeBytes = statSync3(fullPath).size;
+    } catch {
+    }
+    return {
+      path: f,
+      lastModified: getGitLastModified(fullPath, projectRoot),
+      sizeBytes
+    };
+  });
+}
+
+// dist/scanner/skills-parser.js
+import { execFileSync as execFileSync2 } from "node:child_process";
+import { readFile as readFile3 } from "node:fs/promises";
+import { existsSync as existsSync3 } from "node:fs";
+import { join as join5 } from "node:path";
+import { homedir as homedir3 } from "node:os";
+async function parseSkills(projectRoot) {
+  const skills = /* @__PURE__ */ new Map();
+  try {
+    const output = execFileSync2("claude", ["plugin", "list"], { encoding: "utf-8", timeout: 1e4 }).trim();
+    if (output) {
+      for (const line of output.split("\n")) {
+        const name = line.trim().split(/\s+/)[0];
+        if (name) {
+          skills.set(name, {
+            name,
+            source: "machine",
+            machineWide: true,
+            projectSpecific: false
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  const globalSettingsPath = join5(homedir3(), ".claude", "settings.json");
+  await parseSettingsForPlugins(globalSettingsPath, skills, true);
+  const projectSettings = join5(projectRoot, ".claude", "settings.json");
+  const projectLocalSettings = join5(projectRoot, ".claude", "settings.local.json");
+  await parseSettingsForPlugins(projectSettings, skills, false);
+  await parseSettingsForPlugins(projectLocalSettings, skills, false);
+  const skillsMd = join5(projectRoot, "skills.md");
+  if (existsSync3(skillsMd)) {
+    const content = await readFile3(skillsMd, "utf-8");
+    const skillNames = content.match(/^#+\s+(.+)$/gm);
+    if (skillNames) {
+      for (const match of skillNames) {
+        const name = match.replace(/^#+\s+/, "").trim();
+        const existing = skills.get(name);
+        if (existing) {
+          existing.projectSpecific = true;
+        } else {
+          skills.set(name, {
+            name,
+            source: "skills.md",
+            machineWide: false,
+            projectSpecific: true
+          });
+        }
+      }
+    }
+  }
+  return Array.from(skills.values());
+}
+async function parseSettingsForPlugins(settingsPath, skills, isMachineWide) {
+  if (!existsSync3(settingsPath))
+    return;
+  try {
+    const content = await readFile3(settingsPath, "utf-8");
+    const settings = JSON.parse(content);
+    const sections = [settings.plugins, settings.mcpServers, settings.permissions];
+    for (const section of sections) {
+      if (!section || typeof section !== "object")
+        continue;
+      for (const name of Object.keys(section)) {
+        const existing = skills.get(name);
+        if (existing) {
+          if (isMachineWide)
+            existing.machineWide = true;
+          else
+            existing.projectSpecific = true;
+        } else {
+          skills.set(name, {
+            name,
+            source: isMachineWide ? "global settings" : "project settings",
+            machineWide: isMachineWide,
+            projectSpecific: !isMachineWide
+          });
+        }
+      }
+    }
+  } catch {
+  }
+}
+
+// dist/scanner/index.js
+async function scanProject(projectRoot) {
+  const allFiles = await discoverFiles(projectRoot);
+  const rootFiles = identifyRoots(allFiles, projectRoot);
+  const allRefs = [];
+  for (const file of allFiles) {
+    const fullPath = file.startsWith("/") ? file : join6(projectRoot, file);
+    try {
+      const refs = await parseFileReferences(fullPath, projectRoot);
+      allRefs.push(...refs);
+    } catch {
+    }
+  }
+  const graph = buildGraph(allFiles, allRefs, projectRoot);
+  const orphans = detectOrphans(allFiles, allRefs, rootFiles, projectRoot);
+  const staleFiles = detectStaleFiles(allFiles, projectRoot);
+  const skills = await parseSkills(projectRoot);
+  const scanData = JSON.stringify({ graph, orphans, skills, staleFiles });
+  const dataHash = createHash("sha256").update(scanData).digest("hex");
+  return {
+    graph,
+    orphans,
+    skills,
+    staleFiles,
+    scannedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    dataHash
+  };
+}
+async function discoverFiles(projectRoot) {
+  const files = [];
+  const claudeDir = join6(projectRoot, ".claude");
+  if (existsSync4(claudeDir)) {
+    await walkDir(claudeDir, projectRoot, files);
+  }
+  if (existsSync4(join6(projectRoot, "CLAUDE.md"))) {
+    files.push("CLAUDE.md");
+  }
+  if (existsSync4(join6(projectRoot, "skills.md"))) {
+    files.push("skills.md");
+  }
+  const plansDir = join6(projectRoot, "docs", "plans");
+  if (existsSync4(plansDir)) {
+    await walkDir(plansDir, projectRoot, files);
+  }
+  return [...new Set(files)];
+}
+async function walkDir(dir, projectRoot, files) {
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = join6(dir, entry.name);
+    if (entry.isDirectory()) {
+      if (["node_modules", ".git", ".turbo", "cache", "session-env"].includes(entry.name))
+        continue;
+      await walkDir(fullPath, projectRoot, files);
+    } else {
+      const relPath = relative(projectRoot, fullPath);
+      files.push(relPath);
+    }
+  }
+}
+function identifyRoots(allFiles, projectRoot) {
+  const roots = [];
+  for (const rootFile of ROOT_FILES) {
+    if (allFiles.includes(rootFile)) {
+      roots.push(rootFile);
+    }
+  }
+  for (const globalFile of GLOBAL_ROOT_FILES) {
+    const expanded = globalFile.replace("~", homedir4());
+    if (existsSync4(expanded)) {
+      roots.push(globalFile);
+    }
+  }
+  return roots;
+}
+async function readClaudeConfigFiles(projectRoot) {
+  const { readFile: readFile6, stat } = await import("node:fs/promises");
+  const { join: join10 } = await import("node:path");
+  const { existsSync: existsSync9 } = await import("node:fs");
+  const { glob } = await import("glob");
+  const configPatterns = [
+    "CLAUDE.md",
+    ".claude/CLAUDE.md",
+    ".claude/settings.json",
+    ".claude/commands/*.md",
+    ".claude/skills/*.md"
+  ];
+  const files = [];
+  for (const pattern of configPatterns) {
+    const matches = await glob(pattern, { cwd: projectRoot, nodir: true });
+    for (const match of matches) {
+      const fullPath = join10(projectRoot, match);
+      if (!existsSync9(fullPath))
+        continue;
+      try {
+        const content = await readFile6(fullPath, "utf-8");
+        const fileStat = await stat(fullPath);
+        const lastMod = getGitLastModified(fullPath, projectRoot);
+        files.push({
+          filePath: match,
+          content,
+          sizeBytes: fileStat.size,
+          lastModified: lastMod
+        });
+      } catch {
+      }
+    }
+  }
+  return files;
+}
+function detectStaleFiles(allFiles, projectRoot) {
+  const stale = [];
+  const now = Date.now();
+  for (const file of allFiles) {
+    const fullPath = join6(projectRoot, file);
+    const lastMod = getGitLastModified(fullPath, projectRoot);
+    if (lastMod) {
+      const days = Math.floor((now - new Date(lastMod).getTime()) / (1e3 * 60 * 60 * 24));
+      if (days > STALE_THRESHOLD_DAYS) {
+        stale.push({ path: file, lastModified: lastMod, daysSinceModified: days });
+      }
+    }
+  }
+  return stale;
+}
+
+// dist/output/html-generator.js
+function generateOfflineHtml(result, projectRoot) {
+  const title = projectRoot.split("/").pop() ?? "MD4AI";
+  const dataJson = JSON.stringify(result);
+  const orphanItems = result.orphans.map((o) => `<li data-path="${escapeHtml(o.path)}">${escapeHtml(o.path)} <span class="meta">(${o.sizeBytes} bytes)</span></li>`).join("\n");
+  const staleItems = result.staleFiles.map((s) => `<li data-path="${escapeHtml(s.path)}">${escapeHtml(s.path)} <span class="stale-meta">(${s.daysSinceModified} days)</span></li>`).join("\n");
+  const skillRows = result.skills.map((s) => `<tr><td>${escapeHtml(s.name)}</td><td>${s.machineWide ? '<span class="check">\u2713</span>' : ""}</td><td>${s.projectSpecific ? '<span class="check">\u2713</span>' : ""}</td><td class="meta">${escapeHtml(s.source)}</td></tr>`).join("\n");
+  const fileItems = result.graph.nodes.map((n) => `<li data-path="${escapeHtml(n.filePath)}" data-type="${n.type}">${escapeHtml(n.filePath)} <span class="meta">(${n.type})</span></li>`).join("\n");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>MD4AI \u2014 ${escapeHtml(title)}</title>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; background: #0f172a; color: #e2e8f0; padding: 2rem; }
+    h1 { color: #38bdf8; margin-bottom: 0.5rem; }
+    .subtitle { color: #94a3b8; margin-bottom: 2rem; }
+    .section { background: #1e293b; border-radius: 12px; padding: 1.5rem; margin-bottom: 1.5rem; }
+    .section h2 { color: #38bdf8; margin-bottom: 1rem; font-size: 1.2rem; }
+    .mermaid { background: #0f172a; border-radius: 8px; padding: 1rem; overflow-x: auto; }
+    .badge { display: inline-block; padding: 0.25rem 0.75rem; border-radius: 999px; font-size: 0.85rem; margin-left: 0.5rem; }
+    .badge-orphan { background: #ef4444; color: white; }
+    .badge-stale { background: #f59e0b; color: black; }
+    table { width: 100%; border-collapse: collapse; }
+    th, td { padding: 0.5rem 1rem; text-align: left; border-bottom: 1px solid #334155; }
+    th { color: #94a3b8; font-weight: 600; }
+    .check { color: #22c55e; }
+    .meta { color: #94a3b8; }
+    .stale-meta { color: #f59e0b; }
+    .stats { display: flex; gap: 2rem; flex-wrap: wrap; margin-bottom: 1rem; }
+    .stat { text-align: center; }
+    .stat-value { font-size: 2rem; font-weight: bold; color: #38bdf8; }
+    .stat-label { color: #94a3b8; font-size: 0.85rem; }
+    .file-list { list-style: none; }
+    .file-list li { padding: 0.3rem 0; color: #cbd5e1; font-family: monospace; font-size: 0.9rem; }
+    #search { width: 100%; padding: 0.75rem 1rem; background: #0f172a; border: 1px solid #334155; border-radius: 8px; color: #e2e8f0; font-size: 1rem; margin-bottom: 1rem; }
+    #search:focus { outline: none; border-color: #38bdf8; }
+    @media print { body { background: white; color: black; } .section { border: 1px solid #ccc; } }
+  </style>
+</head>
+<body>
+  <h1>MD4AI \u2014 ${escapeHtml(title)}</h1>
+  <p class="subtitle">Scanned: ${new Date(result.scannedAt).toLocaleString()} | Hash: ${result.dataHash.slice(0, 12)}</p>
+
+  <div class="stats">
+    <div class="stat"><div class="stat-value">${result.graph.nodes.length}</div><div class="stat-label">Files</div></div>
+    <div class="stat"><div class="stat-value">${result.graph.edges.length}</div><div class="stat-label">References</div></div>
+    <div class="stat"><div class="stat-value">${result.orphans.length}</div><div class="stat-label">Orphans</div></div>
+    <div class="stat"><div class="stat-value">${result.staleFiles.length}</div><div class="stat-label">Stale</div></div>
+    <div class="stat"><div class="stat-value">${result.skills.length}</div><div class="stat-label">Skills</div></div>
+  </div>
+
+  <input type="text" id="search" placeholder="Search files..." oninput="filterFiles(this.value)">
+
+  <div class="section">
+    <h2>Dependency Graph</h2>
+    <pre class="mermaid">${escapeHtml(result.graph.mermaid)}</pre>
+  </div>
+
+  ${result.orphans.length > 0 ? `
+  <div class="section">
+    <h2>Orphan Files <span class="badge badge-orphan">${result.orphans.length}</span></h2>
+    <p class="meta" style="margin-bottom: 1rem;">Files not reachable from any root configuration file.</p>
+    <ul class="file-list" id="orphan-list">${orphanItems}</ul>
+  </div>
+  ` : ""}
+
+  ${result.staleFiles.length > 0 ? `
+  <div class="section">
+    <h2>Stale Files <span class="badge badge-stale">${result.staleFiles.length}</span></h2>
+    <p class="meta" style="margin-bottom: 1rem;">Files not modified in over 90 days.</p>
+    <ul class="file-list" id="stale-list">${staleItems}</ul>
+  </div>
+  ` : ""}
+
+  <div class="section">
+    <h2>Skills Comparison</h2>
+    <table>
+      <thead><tr><th>Skill/Plugin</th><th>Entire Machine</th><th>Project Specific</th><th>Source</th></tr></thead>
+      <tbody>${skillRows}</tbody>
+    </table>
+  </div>
+
+  <div class="section">
+    <h2>All Files</h2>
+    <ul class="file-list" id="all-files">${fileItems}</ul>
+  </div>
+
+  <script>
+    mermaid.initialize({ startOnLoad: true, theme: 'dark' });
+
+    function filterFiles(query) {
+      var q = query.toLowerCase();
+      document.querySelectorAll('.file-list li').forEach(function(li) {
+        var path = li.getAttribute('data-path') || '';
+        li.style.display = path.toLowerCase().indexOf(q) >= 0 ? '' : 'none';
+      });
+    }
+  </script>
+
+  <script type="application/json" id="scan-data">${dataJson}</script>
+</body>
+</html>`;
+}
+function escapeHtml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+
+// dist/commands/map.js
+async function mapCommand(path, options) {
+  const projectRoot = resolve3(path ?? process.cwd());
+  if (!existsSync5(projectRoot)) {
+    console.error(chalk8.red(`Path not found: ${projectRoot}`));
+    process.exit(1);
+  }
+  console.log(chalk8.blue(`Scanning: ${projectRoot}
+`));
+  const result = await scanProject(projectRoot);
+  console.log(`  Files found:   ${result.graph.nodes.length}`);
+  console.log(`  References:    ${result.graph.edges.length}`);
+  console.log(`  Orphans:       ${result.orphans.length}`);
+  console.log(`  Stale files:   ${result.staleFiles.length}`);
+  console.log(`  Skills:        ${result.skills.length}`);
+  console.log(`  Data hash:     ${result.dataHash.slice(0, 12)}...`);
+  const outputDir = resolve3(projectRoot, "output");
+  if (!existsSync5(outputDir)) {
+    await mkdir2(outputDir, { recursive: true });
+  }
+  const htmlPath = resolve3(outputDir, "index.html");
+  const html = generateOfflineHtml(result, projectRoot);
+  await writeFile2(htmlPath, html, "utf-8");
+  console.log(chalk8.green(`
+Local preview: ${htmlPath}`));
+  if (!options.offline) {
+    try {
+      const { supabase } = await getAuthenticatedClient();
+      const { data: devicePaths } = await supabase.from("device_paths").select("folder_id, device_name").eq("path", projectRoot);
+      if (devicePaths?.length) {
+        const { folder_id, device_name } = devicePaths[0];
+        const { error } = await supabase.from("claude_folders").update({
+          graph_json: result.graph,
+          orphans_json: result.orphans,
+          skills_table_json: result.skills,
+          stale_files_json: result.staleFiles,
+          last_scanned: result.scannedAt,
+          data_hash: result.dataHash
+        }).eq("id", folder_id);
+        if (error) {
+          console.error(chalk8.yellow(`Sync warning: ${error.message}`));
+        } else {
+          await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder_id).eq("device_name", device_name);
+          await saveState({
+            lastFolderId: folder_id,
+            lastDeviceName: device_name,
+            lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+          });
+          console.log(chalk8.green("Synced to Supabase."));
+          console.log(chalk8.cyan(`
+  https://www.md4ai.com/project/${folder_id}
+`));
+          const configFiles = await readClaudeConfigFiles(projectRoot);
+          if (configFiles.length > 0) {
+            for (const file of configFiles) {
+              await supabase.from("folder_files").upsert({
+                folder_id,
+                file_path: file.filePath,
+                content: file.content,
+                size_bytes: file.sizeBytes,
+                last_modified: file.lastModified
+              }, { onConflict: "folder_id,file_path" });
+            }
+            console.log(chalk8.green(`  Uploaded ${configFiles.length} config file(s).`));
+          }
+        }
+      } else {
+        console.log(chalk8.yellow("No device path matches this folder. Run: md4ai add-device\n(Local preview still generated.)"));
+      }
+    } catch {
+      console.log(chalk8.yellow("Not logged in \u2014 local preview only."));
+    }
+  }
+}
+
+// dist/commands/simulate.js
+import { join as join7 } from "node:path";
+import { existsSync as existsSync6 } from "node:fs";
+import { homedir as homedir5 } from "node:os";
+import chalk9 from "chalk";
+async function simulateCommand(prompt) {
+  const projectRoot = process.cwd();
+  console.log(chalk9.blue(`Simulating prompt: "${prompt}"
+`));
+  console.log(chalk9.dim("Files Claude would load:\n"));
+  const globalClaude = join7(homedir5(), ".claude", "CLAUDE.md");
+  if (existsSync6(globalClaude)) {
+    console.log(chalk9.green("  \u2713 ~/.claude/CLAUDE.md (global)"));
+  }
+  for (const rootFile of ROOT_FILES) {
+    const fullPath = join7(projectRoot, rootFile);
+    if (existsSync6(fullPath)) {
+      console.log(chalk9.green(`  \u2713 ${rootFile} (project root)`));
+    }
+  }
+  const settingsFiles = [
+    join7(homedir5(), ".claude", "settings.json"),
+    join7(homedir5(), ".claude", "settings.local.json"),
+    join7(projectRoot, ".claude", "settings.json"),
+    join7(projectRoot, ".claude", "settings.local.json")
+  ];
+  for (const sf of settingsFiles) {
+    if (existsSync6(sf)) {
+      const display = sf.startsWith(homedir5()) ? sf.replace(homedir5(), "~") : sf.replace(projectRoot + "/", "");
+      console.log(chalk9.green(`  \u2713 ${display} (settings)`));
+    }
+  }
+  const words = prompt.split(/\s+/);
+  for (const word of words) {
+    const cleaned = word.replace(/['"]/g, "");
+    const candidatePath = join7(projectRoot, cleaned);
+    if (existsSync6(candidatePath) && cleaned.includes("/")) {
+      console.log(chalk9.cyan(`  \u2192 ${cleaned} (referenced in prompt)`));
+    }
+  }
+  console.log(chalk9.dim("\nNote: This is an approximation. Actual file loading depends on Claude Code internals."));
+}
+
+// dist/commands/print.js
+import { join as join8 } from "node:path";
+import { readFile as readFile4, writeFile as writeFile3 } from "node:fs/promises";
+import { existsSync as existsSync7 } from "node:fs";
+import chalk10 from "chalk";
+async function printCommand(title) {
+  const projectRoot = process.cwd();
+  const scanDataPath = join8(projectRoot, "output", "index.html");
+  if (!existsSync7(scanDataPath)) {
+    console.error(chalk10.red("No scan data found. Run: md4ai update"));
+    process.exit(1);
+  }
+  const html = await readFile4(scanDataPath, "utf-8");
+  const match = html.match(/<script type="application\/json" id="scan-data">([\s\S]*?)<\/script>/);
+  if (!match) {
+    console.error(chalk10.red("Could not extract scan data from output/index.html"));
+    process.exit(1);
+  }
+  const result = JSON.parse(match[1]);
+  const printHtml = generatePrintHtml(result, title);
+  const outputPath = join8(projectRoot, "output", `print-${Date.now()}.html`);
+  await writeFile3(outputPath, printHtml, "utf-8");
+  console.log(chalk10.green(`Print-ready wall sheet: ${outputPath}`));
+}
+function escapeHtml2(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function generatePrintHtml(result, title) {
+  const skillRows = result.skills.map((s) => `<tr><td>${escapeHtml2(s.name)}</td><td>${s.machineWide ? '<span class="check">\u2713</span>' : ""}</td><td>${s.projectSpecific ? '<span class="check">\u2713</span>' : ""}</td></tr>`).join("\n");
+  const orphanItems = result.orphans.map((o) => `<li class="orphan">${escapeHtml2(o.path)}</li>`).join("\n");
+  const staleItems = result.staleFiles.map((s) => `<li class="stale">${escapeHtml2(s.path)} (${s.daysSinceModified}d)</li>`).join("\n");
+  return `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8">
+  <title>${escapeHtml2(title)} \u2014 MD4AI Wall Sheet</title>
+  <script src="https://cdn.jsdelivr.net/npm/mermaid@11/dist/mermaid.min.js"></script>
+  <style>
+    @page { size: A3 landscape; margin: 1cm; }
+    body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', sans-serif; padding: 1rem; }
+    h1 { font-size: 2rem; margin-bottom: 0.5rem; }
+    .subtitle { color: #666; margin-bottom: 2rem; }
+    .mermaid { margin: 2rem 0; }
+    .columns { display: flex; gap: 2rem; }
+    .column { flex: 1; }
+    table { width: 100%; border-collapse: collapse; font-size: 0.85rem; }
+    th, td { padding: 0.3rem 0.5rem; text-align: left; border-bottom: 1px solid #ddd; }
+    th { background: #f5f5f5; }
+    .orphan { color: #dc2626; }
+    .stale { color: #d97706; }
+    .check { color: #16a34a; font-weight: bold; }
+  </style>
+</head>
+<body>
+  <h1>${escapeHtml2(title)}</h1>
+  <p class="subtitle">Generated: ${(/* @__PURE__ */ new Date()).toLocaleString()} | Files: ${result.graph.nodes.length} | Orphans: ${result.orphans.length}</p>
+
+  <pre class="mermaid">${escapeHtml2(result.graph.mermaid)}</pre>
+
+  <div class="columns">
+    <div class="column">
+      <h2>Skills Comparison</h2>
+      <table>
+        <tr><th>Skill</th><th>Machine</th><th>Project</th></tr>
+        ${skillRows}
+      </table>
+    </div>
+    <div class="column">
+      ${result.orphans.length ? `<h2>Orphans</h2><ul>${orphanItems}</ul>` : ""}
+      ${result.staleFiles.length ? `<h2>Stale Files</h2><ul>${staleItems}</ul>` : ""}
+    </div>
+  </div>
+
+  <script>mermaid.initialize({ startOnLoad: true, theme: 'default' });</script>
+</body>
+</html>`;
+}
+
+// dist/commands/sync.js
+import chalk11 from "chalk";
+async function syncCommand(options) {
+  const { supabase } = await getAuthenticatedClient();
+  if (options.all) {
+    const { data: devices, error } = await supabase.from("device_paths").select("folder_id, device_name, path");
+    if (error || !devices?.length) {
+      console.error(chalk11.red("No devices found."));
+      process.exit(1);
+    }
+    for (const device of devices) {
+      console.log(chalk11.blue(`Syncing: ${device.path}`));
+      try {
+        const result = await scanProject(device.path);
+        await supabase.from("claude_folders").update({
+          graph_json: result.graph,
+          orphans_json: result.orphans,
+          skills_table_json: result.skills,
+          stale_files_json: result.staleFiles,
+          last_scanned: result.scannedAt,
+          data_hash: result.dataHash
+        }).eq("id", device.folder_id);
+        await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
+        console.log(chalk11.green(`  Done: ${device.device_name}`));
+      } catch (err) {
+        console.error(chalk11.red(`  Failed: ${device.path}: ${err}`));
+      }
+    }
+    await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
+    console.log(chalk11.green("\nAll devices synced."));
+  } else {
+    const state = await loadState();
+    if (!state.lastFolderId) {
+      console.error(chalk11.yellow("No recent sync. Use: md4ai sync --all, or md4ai update <path> first."));
+      process.exit(1);
+    }
+    const { data: device } = await supabase.from("device_paths").select("folder_id, device_name, path").eq("folder_id", state.lastFolderId).eq("device_name", state.lastDeviceName).single();
+    if (!device) {
+      console.error(chalk11.red("Could not find last synced device/folder."));
+      process.exit(1);
+    }
+    console.log(chalk11.blue(`Syncing: ${device.path}`));
+    const result = await scanProject(device.path);
+    await supabase.from("claude_folders").update({
+      graph_json: result.graph,
+      orphans_json: result.orphans,
+      skills_table_json: result.skills,
+      stale_files_json: result.staleFiles,
+      last_scanned: result.scannedAt,
+      data_hash: result.dataHash
+    }).eq("id", device.folder_id);
+    await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", device.folder_id).eq("device_name", device.device_name);
+    await saveState({ lastSyncAt: (/* @__PURE__ */ new Date()).toISOString() });
+    console.log(chalk11.green("Synced."));
+  }
+}
+
+// dist/commands/link.js
+import { resolve as resolve4 } from "node:path";
+import { hostname as hostname2, platform as platform2 } from "node:os";
+import chalk12 from "chalk";
+function detectOs2() {
+  const p = platform2();
+  if (p === "win32")
+    return "windows";
+  if (p === "darwin")
+    return "macos";
+  if (p === "linux")
+    return "linux";
+  return "other";
+}
+function detectDeviceName() {
+  const os = detectOs2();
+  const host = hostname2().split(".")[0];
+  const osLabel = os.charAt(0).toUpperCase() + os.slice(1);
+  return `${host}-${osLabel}`;
+}
+async function linkCommand(projectId) {
+  const { supabase, userId } = await getAuthenticatedClient();
+  const cwd = resolve4(process.cwd());
+  const deviceName = detectDeviceName();
+  const osType = detectOs2();
+  const { data: folder, error: folderErr } = await supabase.from("claude_folders").select("id, name").eq("id", projectId).single();
+  if (folderErr || !folder) {
+    console.error(chalk12.red("Project not found, or you do not have access."));
+    console.error(chalk12.yellow("Check the project ID in the MD4AI web dashboard."));
+    process.exit(1);
+  }
+  console.log(chalk12.blue(`
+Linking "${folder.name}" to this device...
+`));
+  console.log(`  Project:  ${folder.name}`);
+  console.log(`  Path:     ${cwd}`);
+  console.log(`  Device:   ${deviceName}`);
+  console.log(`  OS:       ${osType}`);
+  await supabase.from("devices").upsert({
+    user_id: userId,
+    device_name: deviceName,
+    os_type: osType
+  }, { onConflict: "user_id,device_name" });
+  const { data: existing } = await supabase.from("device_paths").select("id").eq("folder_id", folder.id).eq("device_name", deviceName).maybeSingle();
+  if (existing) {
+    await supabase.from("device_paths").update({ path: cwd, os_type: osType, last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("id", existing.id);
+  } else {
+    const { error: pathErr } = await supabase.from("device_paths").insert({
+      user_id: userId,
+      folder_id: folder.id,
+      device_name: deviceName,
+      os_type: osType,
+      path: cwd
+    });
+    if (pathErr) {
+      console.error(chalk12.red(`Failed to link: ${pathErr.message}`));
+      process.exit(1);
+    }
+  }
+  console.log(chalk12.green("\nLinked successfully."));
+  console.log(chalk12.blue("\nRunning initial scan...\n"));
+  const result = await scanProject(cwd);
+  console.log(`  Files:     ${result.graph.nodes.length}`);
+  console.log(`  References:${result.graph.edges.length}`);
+  console.log(`  Orphans:   ${result.orphans.length}`);
+  console.log(`  Skills:    ${result.skills.length}`);
+  const { error: scanErr } = await supabase.from("claude_folders").update({
+    graph_json: result.graph,
+    orphans_json: result.orphans,
+    skills_table_json: result.skills,
+    stale_files_json: result.staleFiles,
+    last_scanned: result.scannedAt,
+    data_hash: result.dataHash
+  }).eq("id", folder.id);
+  if (scanErr) {
+    console.error(chalk12.yellow(`Scan upload warning: ${scanErr.message}`));
+  }
+  const configFiles = await readClaudeConfigFiles(cwd);
+  if (configFiles.length > 0) {
+    for (const file of configFiles) {
+      await supabase.from("folder_files").upsert({
+        folder_id: folder.id,
+        file_path: file.filePath,
+        content: file.content,
+        size_bytes: file.sizeBytes,
+        last_modified: file.lastModified
+      }, { onConflict: "folder_id,file_path" });
+    }
+    console.log(chalk12.green(`  Uploaded ${configFiles.length} config file(s).`));
+  }
+  await supabase.from("device_paths").update({ last_synced: (/* @__PURE__ */ new Date()).toISOString() }).eq("folder_id", folder.id).eq("device_name", deviceName);
+  await saveState({
+    lastFolderId: folder.id,
+    lastDeviceName: deviceName,
+    lastSyncAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const projectUrl = `https://www.md4ai.com/project/${folder.id}`;
+  console.log(chalk12.green("\nDone! Project linked and scanned."));
+  console.log(chalk12.cyan(`
+  ${projectUrl}
+`));
+  console.log(chalk12.grey('Run "md4ai update" to rescan at any time.'));
+}
+
+// dist/commands/import-bundle.js
+import { readFile as readFile5, writeFile as writeFile4, mkdir as mkdir3 } from "node:fs/promises";
+import { join as join9, dirname as dirname2 } from "node:path";
+import { existsSync as existsSync8 } from "node:fs";
+import chalk13 from "chalk";
+import { confirm, input as input4 } from "@inquirer/prompts";
+async function importBundleCommand(zipPath) {
+  if (!existsSync8(zipPath)) {
+    console.error(chalk13.red(`File not found: ${zipPath}`));
+    process.exit(1);
+  }
+  const JSZip = (await import("jszip")).default;
+  const zipData = await readFile5(zipPath);
+  const zip = await JSZip.loadAsync(zipData);
+  const manifestFile = zip.file("manifest.json");
+  if (!manifestFile) {
+    console.error(chalk13.red("Invalid bundle: missing manifest.json"));
+    process.exit(1);
+  }
+  const manifest = JSON.parse(await manifestFile.async("string"));
+  console.log(chalk13.blue(`
+Bundle: ${manifest.folderName}`));
+  console.log(`  Exported by: ${manifest.ownerEmail}`);
+  console.log(`  Exported at: ${manifest.exportedAt}`);
+  console.log(`  Files:       ${manifest.fileCount}`);
+  const files = [];
+  for (const [path, file] of Object.entries(zip.files)) {
+    if (path.startsWith("claude-files/") && !file.dir) {
+      const relativePath = path.replace("claude-files/", "");
+      const content = await file.async("string");
+      files.push({ filePath: relativePath, content });
+    }
+  }
+  if (files.length === 0) {
+    console.log(chalk13.yellow("No Claude config files found in bundle."));
+    return;
+  }
+  console.log(chalk13.blue(`
+Files to extract:`));
+  for (const f of files) {
+    console.log(`  ${f.filePath}`);
+  }
+  const targetDir = await input4({
+    message: "Extract to directory:",
+    default: process.cwd()
+  });
+  const proceed = await confirm({
+    message: `Extract ${files.length} file(s) to ${targetDir}?`
+  });
+  if (!proceed) {
+    console.log(chalk13.yellow("Cancelled."));
+    return;
+  }
+  for (const file of files) {
+    const fullPath = join9(targetDir, file.filePath);
+    const dir = dirname2(fullPath);
+    if (!existsSync8(dir)) {
+      await mkdir3(dir, { recursive: true });
+    }
+    await writeFile4(fullPath, file.content, "utf-8");
+    console.log(chalk13.green(`  \u2713 ${file.filePath}`));
+  }
+  console.log(chalk13.green(`
+Done! ${files.length} file(s) extracted to ${targetDir}`));
+}
+
+// dist/index.js
+var program = new Command();
+program.name("md4ai").description("MD4AI \u2014 Claude tooling visualiser").version("0.1.0");
+program.command("login").description("Log in to MD4AI with email and password").action(loginCommand);
+program.command("logout").description("Log out and clear stored credentials").action(logoutCommand);
+program.command("status").description("Show login status, device count, folder count, last sync").action(statusCommand);
+program.command("add-folder").description("Create a new Claude folder").action(addFolderCommand);
+program.command("add-device").description("Add a device path to a Claude folder").action(addDeviceCommand);
+program.command("list-devices").description("List all devices and their linked folders").action(listDevicesCommand);
+program.command("link <project-id>").description("Link the current directory to a project created in the web dashboard").action(linkCommand);
+program.command("update [path]").description("Rescan a Claude project folder and push updated data to your dashboard").option("--offline", "Skip pushing to Supabase").action(mapCommand);
+program.command("simulate <prompt>").description("Show which files Claude would load for a given prompt").action(simulateCommand);
+program.command("print <title>").description("Generate a printable wall-chart HTML from the last scan").action(printCommand);
+program.command("sync").description("Re-push latest scan data to Supabase").option("--all", "Sync all folders on all devices").action(syncCommand);
+program.command("import <zipfile>").description("Import a Claude setup bundle exported from the web dashboard").action(importBundleCommand);
+program.parse();