rulekeeper 0.1.0

package/dist/index.js

@@ -0,0 +1,1879 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/commands/init.ts
+import { join as join5 } from "path";
+
+// src/lib/config.ts
+import { parse, stringify } from "yaml";
+
+// src/lib/paths.ts
+import { homedir } from "os";
+import { join } from "path";
+import envPaths from "env-paths";
+var paths = envPaths("rulekeeper", { suffix: "" });
+function getConfigDir() {
+  return paths.config;
+}
+function getConfigPath() {
+  return join(getConfigDir(), "config.yaml");
+}
+function getClaudeDir(projectPath = process.cwd()) {
+  return join(projectPath, ".claude");
+}
+function getRulekeeperDir(projectPath = process.cwd()) {
+  return join(projectPath, ".rulekeeper");
+}
+function getManifestPath(projectPath = process.cwd()) {
+  return join(getRulekeeperDir(projectPath), "manifest.yaml");
+}
+function getHomeDir() {
+  return homedir();
+}
+function expandTilde(path) {
+  if (path.startsWith("~")) {
+    return join(getHomeDir(), path.slice(1));
+  }
+  return path;
+}
+
+// src/lib/files.ts
+import { existsSync, mkdirSync } from "fs";
+import { readFile, writeFile, copyFile as fsCopyFile, readdir, unlink, rm } from "fs/promises";
+import { dirname, basename } from "path";
+function ensureDir(dirPath) {
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+}
+function fileExists(filePath) {
+  return existsSync(filePath);
+}
+async function readTextFile(filePath) {
+  return await readFile(filePath, "utf-8");
+}
+async function writeTextFile(filePath, content) {
+  ensureDir(dirname(filePath));
+  await writeFile(filePath, content, "utf-8");
+}
+async function copyFile(source, dest) {
+  ensureDir(dirname(dest));
+  await fsCopyFile(source, dest);
+}
+async function deleteFile(filePath) {
+  if (existsSync(filePath)) {
+    await unlink(filePath);
+  }
+}
+async function listFiles(dirPath, extension) {
+  if (!existsSync(dirPath)) {
+    return [];
+  }
+  const entries = await readdir(dirPath, { withFileTypes: true });
+  let files = entries.filter((entry) => entry.isFile()).map((entry) => entry.name);
+  if (extension) {
+    files = files.filter((file) => file.endsWith(extension));
+  }
+  return files;
+}
+function getRuleName(filename) {
+  return basename(filename, ".md");
+}
+function getRuleFilename(ruleName) {
+  const baseName = ruleName.toLowerCase().endsWith(".md") ? ruleName.slice(0, -3) : ruleName;
+  return `${baseName}.md`;
+}
+function normalizeRuleName(ruleName) {
+  const name = ruleName.toLowerCase().endsWith(".md") ? ruleName.slice(0, -3) : ruleName;
+  return name.toLowerCase();
+}
+function findRuleMatch(input, availableRules) {
+  const normalizedInput = normalizeRuleName(input);
+  const match = availableRules.find(
+    (rule) => normalizeRuleName(rule) === normalizedInput
+  );
+  return match ?? null;
+}
+
+// src/types/config.ts
+var DEFAULT_CONFIG = {
+  version: 1,
+  source: {
+    type: "local",
+    path: ""
+  },
+  settings: {
+    autoPull: true,
+    pullFrequency: "daily"
+  }
+};
+
+// src/types/manifest.ts
+var DEFAULT_MANIFEST = {
+  version: 1,
+  rules: {}
+};
+
+// src/lib/config.ts
+async function loadConfig() {
+  const configPath = getConfigPath();
+  if (!fileExists(configPath)) {
+    return null;
+  }
+  const content = await readTextFile(configPath);
+  const config = parse(content);
+  return config;
+}
+async function saveConfig(config) {
+  const configPath = getConfigPath();
+  ensureDir(getConfigDir());
+  const content = stringify(config, { indent: 2 });
+  await writeTextFile(configPath, content);
+}
+async function configExists() {
+  return fileExists(getConfigPath());
+}
+function createConfig(options) {
+  const config = {
+    ...DEFAULT_CONFIG,
+    source: {
+      type: options.sourceType,
+      path: options.sourcePath,
+      remote: options.remote
+    },
+    settings: {
+      autoPull: options.autoPull ?? true,
+      pullFrequency: options.pullFrequency ?? "daily"
+    }
+  };
+  if (options.shell) {
+    config.platform = { shell: options.shell };
+  }
+  return config;
+}
+async function updateConfigLastPull() {
+  const config = await loadConfig();
+  if (config) {
+    config.settings.lastPull = (/* @__PURE__ */ new Date()).toISOString();
+    await saveConfig(config);
+  }
+}
+
+// src/lib/manifest.ts
+import { parse as parse2, stringify as stringify2 } from "yaml";
+async function loadManifest(projectPath = process.cwd()) {
+  const manifestPath = getManifestPath(projectPath);
+  if (!fileExists(manifestPath)) {
+    return null;
+  }
+  const content = await readTextFile(manifestPath);
+  const manifest = parse2(content);
+  return manifest;
+}
+async function saveManifest(manifest, projectPath = process.cwd()) {
+  const manifestPath = getManifestPath(projectPath);
+  ensureDir(getRulekeeperDir(projectPath));
+  const content = stringify2(manifest, { indent: 2 });
+  await writeTextFile(manifestPath, content);
+}
+async function getOrCreateManifest(projectPath = process.cwd()) {
+  const manifest = await loadManifest(projectPath);
+  return manifest ?? { ...DEFAULT_MANIFEST };
+}
+function createRuleEntry(options) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    file: options.file,
+    sourceHash: options.sourceHash,
+    localHash: options.localHash,
+    status: options.status ?? "synced",
+    installedAt: now,
+    updatedAt: now
+  };
+}
+function updateRuleEntry(entry, updates) {
+  return {
+    ...entry,
+    ...updates,
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+}
+async function updateRuleInManifest(ruleName, updates, projectPath = process.cwd()) {
+  const manifest = await loadManifest(projectPath);
+  if (manifest && manifest.rules[ruleName]) {
+    manifest.rules[ruleName] = updateRuleEntry(manifest.rules[ruleName], updates);
+    await saveManifest(manifest, projectPath);
+  }
+}
+
+// src/lib/source.ts
+import { join as join3 } from "path";
+
+// src/lib/hash.ts
+import { createHash } from "crypto";
+import { readFile as readFile2 } from "fs/promises";
+async function hashFile(filePath) {
+  const content = await readFile2(filePath);
+  const hash = createHash("sha256").update(content).digest("hex");
+  return `sha256:${hash}`;
+}
+
+// src/lib/source.ts
+async function getAvailableRules(config) {
+  const sourcePath = config.source.path;
+  if (!fileExists(sourcePath)) {
+    return [];
+  }
+  const files = await listFiles(sourcePath, ".md");
+  return files.map((file) => ({
+    name: getRuleName(file),
+    file,
+    path: join3(sourcePath, file)
+  }));
+}
+async function getRuleSourcePath(ruleName, config) {
+  const filename = getRuleFilename(ruleName);
+  const rulePath = join3(config.source.path, filename);
+  if (!fileExists(rulePath)) {
+    return null;
+  }
+  return rulePath;
+}
+function isGitUrl(url) {
+  return url.startsWith("git@") || url.startsWith("https://github.com") || url.startsWith("https://gitlab.com") || url.startsWith("https://bitbucket.org") || url.endsWith(".git");
+}
+
+// src/lib/git.ts
+import simpleGit from "simple-git";
+import { join as join4 } from "path";
+function isGitRepo(path) {
+  return fileExists(join4(path, ".git"));
+}
+async function cloneRepo(url, targetPath) {
+  const git = simpleGit();
+  await git.clone(url, targetPath);
+}
+async function pullRepo(path) {
+  const git = simpleGit(path);
+  await git.pull();
+}
+async function hasRemote(path) {
+  if (!isGitRepo(path)) return false;
+  const git = simpleGit(path);
+  try {
+    const remotes = await git.getRemotes();
+    return remotes.length > 0;
+  } catch {
+    return false;
+  }
+}
+async function getRemoteUrl(path) {
+  var _a;
+  if (!isGitRepo(path)) return null;
+  const git = simpleGit(path);
+  try {
+    const remotes = await git.getRemotes(true);
+    const origin = remotes.find((r) => r.name === "origin");
+    return ((_a = origin == null ? void 0 : origin.refs) == null ? void 0 : _a.fetch) ?? null;
+  } catch {
+    return null;
+  }
+}
+function shouldPullFromRemote(config) {
+  if (!config.settings.autoPull) return false;
+  if (config.settings.pullFrequency === "never") return false;
+  if (!config.settings.lastPull) return true;
+  const lastPull = new Date(config.settings.lastPull);
+  const now = /* @__PURE__ */ new Date();
+  const hoursSinceLastPull = (now.getTime() - lastPull.getTime()) / (1e3 * 60 * 60);
+  switch (config.settings.pullFrequency) {
+    case "always":
+      return true;
+    case "daily":
+      return hoursSinceLastPull >= 24;
+    case "weekly":
+      return hoursSinceLastPull >= 168;
+    default:
+      return false;
+  }
+}
+async function pullSourceIfNeeded(config) {
+  const sourcePath = config.source.path;
+  if (!isGitRepo(sourcePath)) {
+    return { pulled: false };
+  }
+  if (!shouldPullFromRemote(config)) {
+    return { pulled: false };
+  }
+  if (!await hasRemote(sourcePath)) {
+    return { pulled: false };
+  }
+  try {
+    await pullRepo(sourcePath);
+    return { pulled: true };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return { pulled: false, error: message };
+  }
+}
+
+// src/lib/platform.ts
+function isWindows() {
+  return process.platform === "win32";
+}
+function isWSL() {
+  if (process.platform !== "linux") return false;
+  return !!(process.env.WSL_DISTRO_NAME || process.env.WSL_INTEROP);
+}
+function detectWindowsShell() {
+  if (isWSL()) {
+    return "wsl";
+  }
+  if (!isWindows()) return null;
+  if (process.env.MSYSTEM) {
+    return "gitbash";
+  }
+  return "standard";
+}
+
+// src/ui/format.ts
+import pc from "picocolors";
+function formatRuleStatus(status2) {
+  switch (status2) {
+    case "synced":
+      return pc.green("\u2713");
+    case "outdated":
+      return pc.yellow("\u2193");
+    case "diverged":
+      return pc.red("\u26A0");
+    case "detached":
+      return pc.dim("\u25CB");
+    default:
+      return pc.dim("?");
+  }
+}
+function formatRuleStatusText(status2) {
+  switch (status2) {
+    case "synced":
+      return pc.green("synced");
+    case "outdated":
+      return pc.yellow("outdated");
+    case "diverged":
+      return pc.red("diverged");
+    case "detached":
+      return pc.dim("detached");
+    default:
+      return pc.dim("unknown");
+  }
+}
+function formatRuleLine(name, status2, details) {
+  const icon = formatRuleStatus(status2);
+  const statusText = formatRuleStatusText(status2);
+  const detailsPart = details ? pc.dim(` (${details})`) : "";
+  return `  ${icon} ${name.padEnd(20)} ${statusText}${detailsPart}`;
+}
+function formatPath(path) {
+  return pc.cyan(path);
+}
+function formatCommand(command) {
+  return pc.cyan(`\`${command}\``);
+}
+function formatHeader(text2) {
+  return pc.bold(text2);
+}
+function formatDiffAdd(line) {
+  return pc.green(`+ ${line}`);
+}
+function formatDiffRemove(line) {
+  return pc.red(`- ${line}`);
+}
+function formatDiffContext(line) {
+  return pc.dim(`  ${line}`);
+}
+function formatDiffHeader(line) {
+  return pc.cyan(line);
+}
+
+// src/ui/messages.ts
+import pc2 from "picocolors";
+var messages = {
+  // General
+  notConfigured: `RuleKeeper is not configured. Run ${formatCommand("rk init")} first.`,
+  noManifest: `No RuleKeeper manifest found. Run ${formatCommand("rk add")} first.`,
+  noClaudeDir: `No .claude/ directory found. Are you in a project root?`,
+  // Init
+  initWelcome: "Welcome to RuleKeeper!",
+  initSuccess: "RuleKeeper is now configured.",
+  initAlreadyExists: "RuleKeeper is already configured. Use --force to reconfigure.",
+  // Source
+  sourceNotFound: (path) => `Source path does not exist: ${formatPath(path)}`,
+  sourceInvalid: "Invalid source path or URL.",
+  sourceUpdated: (path) => `Source updated to: ${formatPath(path)}`,
+  // Add
+  addSuccess: (count) => `Added ${count} rule${count !== 1 ? "s" : ""}.`,
+  addConflict: (files) => `The following files already exist in .claude/:
+${files.map((f) => `  - ${f}`).join("\n")}`,
+  addNoRules: "No rules specified. Use --all to add all available rules.",
+  ruleNotFound: (name) => `Rule '${name}' not found in source.`,
+  // Remove
+  removeSuccess: (count) => `Removed ${count} rule${count !== 1 ? "s" : ""}.`,
+  removeNotInstalled: (name) => `Rule '${name}' is not installed.`,
+  // Status
+  statusAllSynced: "All rules are synced.",
+  statusNeedsAttention: (count) => `${count} rule${count !== 1 ? "s" : ""} need${count === 1 ? "s" : ""} attention. Run ${formatCommand("rk pull")} to update.`,
+  statusOffline: pc2.dim("\u26A0 Could not check for updates (offline?)"),
+  // Pull
+  pullSuccess: (count) => `${count} rule${count !== 1 ? "s" : ""} updated.`,
+  pullSkipped: (count) => `${count} rule${count !== 1 ? "s" : ""} skipped.`,
+  pullDetached: (count) => `${count} rule${count !== 1 ? "s" : ""} detached.`,
+  pullUpToDate: "All rules are up to date.",
+  pullDiverged: (name) => `${name}.md has local changes`,
+  pullDivergedAndOutdated: (name) => `${name}.md has local changes AND source has been updated`,
+  // Detach/Attach
+  detachSuccess: (name) => `Rule '${name}' is now detached.`,
+  detachAlready: (name) => `Rule '${name}' is already detached.`,
+  attachSuccess: (name) => `Rule '${name}' is now attached.`,
+  attachAlready: (name) => `Rule '${name}' is already attached.`,
+  // Diff
+  diffNoDifference: (name) => `No difference found for '${name}'.`,
+  diffNoRules: "No diverged rules to show.",
+  // Doctor
+  doctorAllGood: "All checks passed.",
+  doctorIssuesFound: (count) => `${count} issue${count !== 1 ? "s" : ""} found.`,
+  // Errors
+  errorGeneric: (err) => `Error: ${err}`,
+  errorMissingSource: (name) => `Source file for '${name}' no longer exists.`,
+  errorMissingLocal: (name) => `Local file for '${name}' is missing.`
+};
+
+// src/ui/prompts.ts
+import * as p from "@clack/prompts";
+import pc3 from "picocolors";
+function isCancel2(value) {
+  return p.isCancel(value);
+}
+async function selectSourceType() {
+  return await p.select({
+    message: "Where are your Claude rules stored?",
+    options: [
+      { value: "local", label: "Local folder", hint: "Already cloned git repo or static folder" },
+      { value: "git", label: "Git repository", hint: "Clone now from URL" }
+    ]
+  });
+}
+async function inputSourcePath() {
+  return await p.text({
+    message: "Enter the path to your rules folder:",
+    placeholder: "~/Documents/claude-rules",
+    validate: (value) => {
+      if (!value) return "Path is required";
+      return void 0;
+    }
+  });
+}
+async function inputGitUrl() {
+  return await p.text({
+    message: "Enter the Git repository URL:",
+    placeholder: "git@github.com:username/claude-rules.git",
+    validate: (value) => {
+      if (!value) return "URL is required";
+      return void 0;
+    }
+  });
+}
+async function inputClonePath() {
+  return await p.text({
+    message: "Where should the repository be cloned?",
+    placeholder: "~/Documents/claude-rules",
+    validate: (value) => {
+      if (!value) return "Path is required";
+      return void 0;
+    }
+  });
+}
+async function selectPullFrequency() {
+  return await p.select({
+    message: "How often should RuleKeeper check for updates?",
+    options: [
+      { value: "daily", label: "Daily", hint: "Recommended" },
+      { value: "always", label: "Always", hint: "Every command" },
+      { value: "weekly", label: "Weekly" },
+      { value: "never", label: "Never", hint: "Manual only" }
+    ]
+  });
+}
+async function selectWindowsShell() {
+  return await p.select({
+    message: "Which shell environment are you using?",
+    options: [
+      { value: "standard", label: "Standard (CMD/PowerShell)" },
+      { value: "gitbash", label: "Git Bash" },
+      { value: "wsl", label: "WSL (Windows Subsystem for Linux)" }
+    ]
+  });
+}
+async function selectRulesToAdd(available, installed) {
+  const options = available.map((rule) => ({
+    value: rule,
+    label: rule,
+    hint: installed.includes(rule) ? "already installed" : void 0
+  }));
+  return await p.multiselect({
+    message: "Select rules to add:",
+    options,
+    required: true
+  });
+}
+async function handleDivergedRule(ruleName, sourceAlsoChanged, isSingleRule) {
+  const message = sourceAlsoChanged ? `${ruleName}.md has local changes AND source has been updated` : `${ruleName}.md has local changes`;
+  p.log.warn(message);
+  const options = [
+    {
+      value: "overwrite",
+      label: "Overwrite",
+      hint: "Replace with source version (local changes will be lost)"
+    },
+    {
+      value: "detach",
+      label: "Detach",
+      hint: "Keep local version, stop tracking this rule"
+    }
+  ];
+  if (sourceAlsoChanged) {
+    options.push({
+      value: "view-diff",
+      label: "View diff",
+      hint: "See differences before deciding"
+    });
+  }
+  options.push(
+    isSingleRule ? { value: "cancel", label: "Cancel", hint: "Abort this operation" } : { value: "skip", label: "Skip", hint: "Do nothing for now" }
+  );
+  const action = await p.select({
+    message: "What would you like to do?",
+    options
+  });
+  if (p.isCancel(action)) {
+    return isSingleRule ? "cancel" : "skip";
+  }
+  return action;
+}
+async function handleMissingSource(ruleName) {
+  p.log.warn(`${ruleName}.md - source file no longer exists`);
+  return await p.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "keep", label: "Keep local", hint: "Detach and keep the local file" },
+      { value: "remove", label: "Remove", hint: "Delete from project and manifest" }
+    ]
+  });
+}
+async function handleMissingLocal(ruleName) {
+  p.log.warn(`${ruleName}.md - local file missing`);
+  return await p.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "restore", label: "Restore", hint: "Copy from source" },
+      { value: "remove", label: "Remove", hint: "Remove from manifest" }
+    ]
+  });
+}
+async function handleAttachDiffers(ruleName) {
+  p.log.warn(`${ruleName}.md differs from source version`);
+  return await p.select({
+    message: "What would you like to do?",
+    options: [
+      { value: "overwrite", label: "Overwrite local", hint: "Replace with source version" },
+      { value: "keep", label: "Keep local", hint: "Attach but keep local version (will show as diverged)" },
+      { value: "cancel", label: "Cancel", hint: "Keep detached" }
+    ]
+  });
+}
+function spinner2() {
+  return p.spinner();
+}
+function intro2(message) {
+  p.intro(pc3.bgCyan(pc3.black(` ${message} `)));
+}
+function outro2(message) {
+  p.outro(message);
+}
+var log2 = p.log;
+
+// src/commands/init.ts
+async function init(options = {}) {
+  intro2(messages.initWelcome);
+  if (!options.force && await configExists()) {
+    log2.warn(messages.initAlreadyExists);
+    return;
+  }
+  const sourceType = await selectSourceType();
+  if (isCancel2(sourceType)) {
+    log2.info("Setup cancelled.");
+    return;
+  }
+  let sourcePath;
+  let remote;
+  let detectedSourceType = sourceType;
+  if (sourceType === "git") {
+    while (true) {
+      const gitUrl = await inputGitUrl();
+      if (isCancel2(gitUrl)) {
+        log2.info("Setup cancelled.");
+        return;
+      }
+      const clonePath = await inputClonePath();
+      if (isCancel2(clonePath)) {
+        log2.info("Setup cancelled.");
+        return;
+      }
+      const expandedClonePath = expandTilde(clonePath);
+      const s = spinner2();
+      s.start("Cloning repository...");
+      try {
+        ensureDir(join5(expandedClonePath, ".."));
+        await cloneRepo(gitUrl, expandedClonePath);
+        s.stop("Repository cloned successfully.");
+        sourcePath = expandedClonePath;
+        remote = gitUrl;
+        break;
+      } catch (error) {
+        s.stop("Failed to clone repository.");
+        log2.error(error instanceof Error ? error.message : String(error));
+        log2.info("Please try again.");
+      }
+    }
+  } else {
+    while (true) {
+      const localPath = await inputSourcePath();
+      if (isCancel2(localPath)) {
+        log2.info("Setup cancelled.");
+        return;
+      }
+      const expandedPath = expandTilde(localPath);
+      if (!fileExists(expandedPath)) {
+        log2.error(messages.sourceNotFound(expandedPath));
+        log2.info("Please try again.");
+        continue;
+      }
+      sourcePath = expandedPath;
+      if (isGitRepo(expandedPath)) {
+        const detectedRemote = await getRemoteUrl(expandedPath);
+        if (detectedRemote) {
+          detectedSourceType = "git";
+          remote = detectedRemote;
+          log2.info(`Detected git repository with remote: ${detectedRemote}`);
+        }
+      }
+      break;
+    }
+  }
+  const pullFrequency = await selectPullFrequency();
+  if (isCancel2(pullFrequency)) {
+    log2.info("Setup cancelled.");
+    return;
+  }
+  let shell;
+  if (isWindows()) {
+    const detectedShell = detectWindowsShell();
+    if (detectedShell) {
+      log2.info(`Detected shell: ${detectedShell}`);
+      shell = detectedShell;
+    } else {
+      const selectedShell = await selectWindowsShell();
+      if (isCancel2(selectedShell)) {
+        log2.info("Setup cancelled.");
+        return;
+      }
+      shell = selectedShell;
+    }
+  }
+  const config = createConfig({
+    sourceType: detectedSourceType,
+    sourcePath,
+    remote,
+    autoPull: true,
+    pullFrequency,
+    shell
+  });
+  await saveConfig(config);
+  outro2(messages.initSuccess);
+}
+
+// src/commands/add.ts
+import { join as join6 } from "path";
+async function add(rules, options = {}) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const s = spinner2();
+  s.start("Checking for updates...");
+  const pullResult = await pullSourceIfNeeded(config);
+  if (pullResult.pulled) {
+    await updateConfigLastPull();
+  }
+  s.stop(pullResult.error ? messages.statusOffline : "Source is up to date.");
+  const availableRules = await getAvailableRules(config);
+  if (availableRules.length === 0) {
+    log2.error("No rules found in source.");
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  const installedRules = manifest ? Object.keys(manifest.rules) : [];
+  let rulesToAdd;
+  if (options.all) {
+    rulesToAdd = availableRules.map((r) => r.name);
+  } else if (rules.length > 0) {
+    rulesToAdd = rules;
+  } else {
+    const selected = await selectRulesToAdd(
+      availableRules.map((r) => r.name),
+      installedRules
+    );
+    if (isCancel2(selected)) {
+      log2.info("Cancelled.");
+      return;
+    }
+    rulesToAdd = selected;
+  }
+  if (rulesToAdd.length === 0) {
+    log2.warn(messages.addNoRules);
+    return;
+  }
+  const availableRuleNames = availableRules.map((r) => r.name);
+  const resolvedRules = [];
+  const invalidRules = [];
+  for (const rule of rulesToAdd) {
+    const match = findRuleMatch(rule, availableRuleNames);
+    if (match) {
+      resolvedRules.push(match);
+    } else {
+      invalidRules.push(rule);
+    }
+  }
+  if (invalidRules.length > 0) {
+    for (const rule of invalidRules) {
+      log2.error(messages.ruleNotFound(rule));
+    }
+    process.exit(1);
+  }
+  const claudeDir = getClaudeDir();
+  ensureDir(claudeDir);
+  const updatedManifest = await getOrCreateManifest();
+  let addedCount = 0;
+  let skippedCount = 0;
+  for (const rule of resolvedRules) {
+    const sourcePath = await getRuleSourcePath(rule, config);
+    if (!sourcePath) continue;
+    const filename = getRuleFilename(rule);
+    const targetPath = join6(claudeDir, filename);
+    const sourceHash = await hashFile(sourcePath);
+    if (fileExists(targetPath)) {
+      const localHash = await hashFile(targetPath);
+      const entry = updatedManifest.rules[rule];
+      if (entry && localHash === entry.localHash) {
+        await copyFile(sourcePath, targetPath);
+        const newHash = await hashFile(targetPath);
+        updatedManifest.rules[rule] = createRuleEntry({
+          file: filename,
+          sourceHash: newHash,
+          localHash: newHash
+        });
+        log2.success(`Updated ${filename}`);
+        addedCount++;
+        continue;
+      }
+      if (!entry || localHash !== entry.localHash) {
+        const action = await handleDivergedRule(rule, false, false);
+        if (isCancel2(action) || action === "skip") {
+          skippedCount++;
+          continue;
+        }
+        if (action === "detach") {
+          updatedManifest.rules[rule] = createRuleEntry({
+            file: filename,
+            sourceHash,
+            localHash,
+            status: "detached"
+          });
+          updatedManifest.rules[rule].detachedAt = (/* @__PURE__ */ new Date()).toISOString();
+          log2.info(`${filename} kept as detached`);
+          continue;
+        }
+      }
+    }
+    try {
+      await copyFile(sourcePath, targetPath);
+      const hash = await hashFile(targetPath);
+      updatedManifest.rules[rule] = createRuleEntry({
+        file: filename,
+        sourceHash: hash,
+        localHash: hash
+      });
+      log2.success(`Added ${filename}`);
+      addedCount++;
+    } catch (error) {
+      log2.error(`Failed to add ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  await saveManifest(updatedManifest);
+  if (addedCount > 0) {
+    log2.info(messages.addSuccess(addedCount));
+  }
+  if (skippedCount > 0) {
+    log2.info(`${skippedCount} rule(s) skipped.`);
+  }
+}
+
+// src/commands/remove.ts
+import { join as join7 } from "path";
+async function remove(rules, options = {}) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  if (!manifest) {
+    log2.error(messages.noManifest);
+    process.exit(1);
+  }
+  if (rules.length === 0) {
+    log2.error("No rules specified.");
+    process.exit(1);
+  }
+  const claudeDir = getClaudeDir();
+  const manifestRules = Object.keys(manifest.rules);
+  let removedCount = 0;
+  for (const rule of rules) {
+    const match = findRuleMatch(rule, manifestRules);
+    if (!match) {
+      log2.warn(messages.removeNotInstalled(rule));
+      continue;
+    }
+    const filename = getRuleFilename(match);
+    const targetPath = join7(claudeDir, filename);
+    if (!options.keepFile) {
+      try {
+        await deleteFile(targetPath);
+      } catch (error) {
+        log2.warn(`Could not delete ${filename}: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
+    delete manifest.rules[match];
+    log2.success(`Removed ${match}`);
+    removedCount++;
+  }
+  await saveManifest(manifest);
+  if (removedCount > 0) {
+    log2.info(messages.removeSuccess(removedCount));
+  }
+}
+
+// src/commands/status.ts
+import { join as join8 } from "path";
+async function status() {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  if (!manifest) {
+    log2.error(messages.noManifest);
+    process.exit(1);
+  }
+  const s = spinner2();
+  s.start("Checking for updates...");
+  const pullResult = await pullSourceIfNeeded(config);
+  if (pullResult.pulled) {
+    await updateConfigLastPull();
+  }
+  s.stop("");
+  if (pullResult.error) {
+    log2.warn(messages.statusOffline);
+  }
+  const ruleNames = Object.keys(manifest.rules);
+  if (ruleNames.length === 0) {
+    log2.info("No rules installed.");
+    return;
+  }
+  console.log("");
+  console.log(formatHeader("RuleKeeper Status"));
+  console.log("");
+  const claudeDir = getClaudeDir();
+  let needsAttention = 0;
+  for (const ruleName of ruleNames.sort()) {
+    const entry = manifest.rules[ruleName];
+    const filename = getRuleFilename(ruleName);
+    const localPath = join8(claudeDir, filename);
+    const sourcePath = join8(config.source.path, filename);
+    const result = await checkRuleStatus(entry, localPath, sourcePath);
+    let details;
+    switch (result.status) {
+      case "outdated":
+        details = "source updated";
+        needsAttention++;
+        break;
+      case "diverged":
+        details = "local changes detected";
+        needsAttention++;
+        break;
+      case "detached":
+        break;
+      case "synced":
+        break;
+    }
+    if (!result.localExists) {
+      details = "local file missing";
+      needsAttention++;
+    } else if (!result.sourceExists) {
+      details = "source file missing";
+      needsAttention++;
+    }
+    console.log(formatRuleLine(ruleName + ".md", result.status, details));
+  }
+  console.log("");
+  if (needsAttention > 0) {
+    log2.info(messages.statusNeedsAttention(needsAttention));
+  } else {
+    log2.success(messages.statusAllSynced);
+  }
+}
+async function checkRuleStatus(entry, localPath, sourcePath) {
+  const localExists = fileExists(localPath);
+  const sourceExists = fileExists(sourcePath);
+  if (entry.status === "detached") {
+    return {
+      status: "detached",
+      localChanged: false,
+      sourceChanged: false,
+      localExists,
+      sourceExists
+    };
+  }
+  if (!localExists || !sourceExists) {
+    return {
+      status: "diverged",
+      localChanged: !localExists,
+      sourceChanged: !sourceExists,
+      localExists,
+      sourceExists
+    };
+  }
+  const currentLocalHash = await hashFile(localPath);
+  const currentSourceHash = await hashFile(sourcePath);
+  const localChanged = currentLocalHash !== entry.localHash;
+  const sourceChanged = currentSourceHash !== entry.sourceHash;
+  let status2;
+  if (localChanged) {
+    status2 = "diverged";
+  } else if (sourceChanged) {
+    status2 = "outdated";
+  } else {
+    status2 = "synced";
+  }
+  return {
+    status: status2,
+    localChanged,
+    sourceChanged,
+    localExists,
+    sourceExists,
+    currentLocalHash,
+    currentSourceHash
+  };
+}
+
+// src/commands/pull.ts
+import { join as join10 } from "path";
+
+// src/commands/diff.ts
+import { join as join9 } from "path";
+async function diff(rules, options = {}) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  if (!manifest) {
+    log2.error(messages.noManifest);
+    process.exit(1);
+  }
+  const claudeDir = getClaudeDir();
+  let rulesToDiff;
+  if (options.all) {
+    rulesToDiff = [];
+    for (const [ruleName, entry] of Object.entries(manifest.rules)) {
+      if (entry.status === "detached") continue;
+      const filename = getRuleFilename(ruleName);
+      const localPath = join9(claudeDir, filename);
+      if (!fileExists(localPath)) continue;
+      const currentLocalHash = await hashFile(localPath);
+      if (currentLocalHash !== entry.localHash) {
+        rulesToDiff.push(ruleName);
+      }
+    }
+    if (rulesToDiff.length === 0) {
+      log2.info(messages.diffNoRules);
+      return;
+    }
+  } else if (rules.length > 0) {
+    const manifestRules = Object.keys(manifest.rules);
+    rulesToDiff = [];
+    for (const rule of rules) {
+      const match = findRuleMatch(rule, manifestRules);
+      if (match) {
+        rulesToDiff.push(match);
+      } else {
+        log2.warn(`Rule '${rule}' not found in manifest`);
+      }
+    }
+  } else {
+    log2.error("Specify a rule name or use --all to see all diverged rules.");
+    process.exit(1);
+  }
+  for (const ruleName of rulesToDiff) {
+    const entry = manifest.rules[ruleName];
+    if (!entry) continue;
+    const filename = getRuleFilename(ruleName);
+    const localPath = join9(claudeDir, filename);
+    const sourcePath = join9(config.source.path, filename);
+    await showRuleDiff(ruleName, sourcePath, localPath);
+  }
+}
+async function showDiff(rules) {
+  return diff(rules, {});
+}
+async function showRuleDiff(ruleName, sourcePath, localPath) {
+  const sourceExists = fileExists(sourcePath);
+  const localExists = fileExists(localPath);
+  console.log("");
+  console.log(formatHeader(`Comparing ${ruleName}.md`));
+  console.log("");
+  if (!sourceExists && !localExists) {
+    log2.warn("Both source and local files are missing");
+    return;
+  }
+  if (!sourceExists) {
+    log2.warn("Source file no longer exists");
+    console.log(formatDiffHeader(`--- source (missing)`));
+    console.log(formatDiffHeader(`+++ local (${formatPath(localPath)})`));
+    return;
+  }
+  if (!localExists) {
+    log2.warn("Local file is missing");
+    console.log(formatDiffHeader(`--- source (${formatPath(sourcePath)})`));
+    console.log(formatDiffHeader(`+++ local (missing)`));
+    return;
+  }
+  const sourceContent = await readTextFile(sourcePath);
+  const localContent = await readTextFile(localPath);
+  if (sourceContent === localContent) {
+    log2.info(messages.diffNoDifference(ruleName));
+    return;
+  }
+  console.log(formatDiffHeader(`--- source (${sourcePath})`));
+  console.log(formatDiffHeader(`+++ local (${localPath})`));
+  console.log("");
+  const sourceLines = sourceContent.split("\n");
+  const localLines = localContent.split("\n");
+  const diff2 = computeSimpleDiff(sourceLines, localLines);
+  for (const line of diff2) {
+    if (line.type === "add") {
+      console.log(formatDiffAdd(line.content));
+    } else if (line.type === "remove") {
+      console.log(formatDiffRemove(line.content));
+    } else {
+      console.log(formatDiffContext(line.content));
+    }
+  }
+  console.log("");
+}
+function computeSimpleDiff(source, local) {
+  const result = [];
+  const maxLen = Math.max(source.length, local.length);
+  const sourceSet2 = new Set(source);
+  const localSet = new Set(local);
+  let si = 0;
+  let li = 0;
+  while (si < source.length || li < local.length) {
+    if (si >= source.length) {
+      result.push({ type: "add", content: local[li] });
+      li++;
+    } else if (li >= local.length) {
+      result.push({ type: "remove", content: source[si] });
+      si++;
+    } else if (source[si] === local[li]) {
+      result.push({ type: "context", content: source[si] });
+      si++;
+      li++;
+    } else if (!localSet.has(source[si])) {
+      result.push({ type: "remove", content: source[si] });
+      si++;
+    } else if (!sourceSet2.has(local[li])) {
+      result.push({ type: "add", content: local[li] });
+      li++;
+    } else {
+      result.push({ type: "remove", content: source[si] });
+      result.push({ type: "add", content: local[li] });
+      si++;
+      li++;
+    }
+  }
+  return result;
+}
+
+// src/commands/pull.ts
+async function pull(rules, options = {}) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  if (!manifest) {
+    log2.error(messages.noManifest);
+    process.exit(1);
+  }
+  const s = spinner2();
+  s.start("Checking for updates...");
+  const pullResult = await pullSourceIfNeeded(config);
+  if (pullResult.pulled) {
+    await updateConfigLastPull();
+  }
+  s.stop("");
+  if (pullResult.error) {
+    log2.warn(messages.statusOffline);
+  }
+  const manifestRules = Object.keys(manifest.rules);
+  let rulesToProcess;
+  if (rules.length > 0) {
+    rulesToProcess = [];
+    for (const rule of rules) {
+      const match = findRuleMatch(rule, manifestRules);
+      if (match) {
+        rulesToProcess.push(match);
+      } else {
+        log2.warn(`Rule '${rule}' not found in manifest`);
+      }
+    }
+  } else {
+    rulesToProcess = manifestRules;
+  }
+  const results = {
+    updated: [],
+    skipped: [],
+    detached: [],
+    failed: []
+  };
+  const claudeDir = getClaudeDir();
+  const isSingleRule = rules.length === 1;
+  for (const ruleName of rulesToProcess) {
+    const entry = manifest.rules[ruleName];
+    if (!entry) {
+      log2.warn(`Rule '${ruleName}' not found in manifest`);
+      results.failed.push(ruleName);
+      continue;
+    }
+    if (entry.status === "detached" && !options.includeDetached) {
+      log2.info(`\u25CB ${ruleName}.md (detached - skipped)`);
+      results.skipped.push(ruleName);
+      continue;
+    }
+    const filename = getRuleFilename(ruleName);
+    const sourcePath = join10(config.source.path, filename);
+    const localPath = join10(claudeDir, filename);
+    if (!fileExists(sourcePath)) {
+      const action = await handleMissingSource(ruleName);
+      if (isCancel2(action)) {
+        results.skipped.push(ruleName);
+        continue;
+      }
+      if (action === "keep") {
+        manifest.rules[ruleName] = {
+          ...entry,
+          status: "detached",
+          detachedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        results.detached.push(ruleName);
+      } else if (action === "remove") {
+        await deleteFile(localPath);
+        delete manifest.rules[ruleName];
+        log2.success(`Removed ${ruleName}`);
+      }
+      continue;
+    }
+    if (!fileExists(localPath)) {
+      const action = await handleMissingLocal(ruleName);
+      if (isCancel2(action)) {
+        results.skipped.push(ruleName);
+        continue;
+      }
+      if (action === "restore") {
+        await copyFile(sourcePath, localPath);
+        const hash = await hashFile(localPath);
+        manifest.rules[ruleName] = {
+          ...entry,
+          sourceHash: hash,
+          localHash: hash,
+          status: "synced",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        log2.success(`Restored ${ruleName}.md`);
+        results.updated.push(ruleName);
+      } else if (action === "remove") {
+        delete manifest.rules[ruleName];
+        log2.success(`Removed ${ruleName} from manifest`);
+      }
+      continue;
+    }
+    const result = await pullRule(
+      ruleName,
+      entry,
+      sourcePath,
+      localPath,
+      manifest,
+      options,
+      isSingleRule
+    );
+    switch (result) {
+      case "updated":
+        log2.success(`\u2713 ${ruleName}.md updated`);
+        results.updated.push(ruleName);
+        break;
+      case "detached":
+        log2.info(`\u25CB ${ruleName}.md detached`);
+        results.detached.push(ruleName);
+        break;
+      case "skipped":
+        results.skipped.push(ruleName);
+        break;
+      case "cancelled":
+        await saveManifest(manifest);
+        return;
+    }
+  }
+  await saveManifest(manifest);
+  console.log("");
+  if (results.updated.length > 0) {
+    log2.success(messages.pullSuccess(results.updated.length));
+  }
+  if (results.detached.length > 0) {
+    log2.info(messages.pullDetached(results.detached.length));
+  }
+  if (results.failed.length > 0) {
+    log2.error(`${results.failed.length} rule(s) failed`);
+  }
+  if (results.updated.length === 0 && results.detached.length === 0 && results.failed.length === 0) {
+    log2.success(messages.pullUpToDate);
+  }
+}
+async function pullRule(ruleName, entry, sourcePath, localPath, manifest, options, isSingleRule) {
+  const currentLocalHash = await hashFile(localPath);
+  const currentSourceHash = await hashFile(sourcePath);
+  const localChanged = currentLocalHash !== entry.localHash;
+  const sourceChanged = currentSourceHash !== entry.sourceHash;
+  if (!localChanged && !sourceChanged) {
+    return "skipped";
+  }
+  if (!localChanged && sourceChanged) {
+    await copyFile(sourcePath, localPath);
+    manifest.rules[ruleName] = {
+      ...entry,
+      sourceHash: currentSourceHash,
+      localHash: currentSourceHash,
+      status: "synced",
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    return "updated";
+  }
+  if (localChanged) {
+    if (options.force) {
+      await copyFile(sourcePath, localPath);
+      const newHash = await hashFile(localPath);
+      manifest.rules[ruleName] = {
+        ...entry,
+        sourceHash: currentSourceHash,
+        localHash: newHash,
+        status: "synced",
+        updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      return "updated";
+    }
+    let action = await handleDivergedRule(ruleName, sourceChanged, isSingleRule);
+    while (action === "view-diff") {
+      await showDiff([ruleName]);
+      action = await handleDivergedRule(ruleName, sourceChanged, isSingleRule);
+    }
+    if (isCancel2(action)) {
+      return isSingleRule ? "cancelled" : "skipped";
+    }
+    switch (action) {
+      case "overwrite":
+        await copyFile(sourcePath, localPath);
+        const newHash = await hashFile(localPath);
+        manifest.rules[ruleName] = {
+          ...entry,
+          sourceHash: currentSourceHash,
+          localHash: newHash,
+          status: "synced",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return "updated";
+      case "detach":
+        manifest.rules[ruleName] = {
+          ...entry,
+          status: "detached",
+          detachedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        return "detached";
+      case "skip":
+      case "cancel":
+        return isSingleRule ? "cancelled" : "skipped";
+    }
+  }
+  return "skipped";
+}
+
+// src/commands/list.ts
+import pc4 from "picocolors";
+async function list(options = {}) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const s = spinner2();
+  s.start("Checking source...");
+  const pullResult = await pullSourceIfNeeded(config);
+  if (pullResult.pulled) {
+    await updateConfigLastPull();
+  }
+  s.stop("");
+  if (pullResult.error) {
+    log2.warn(messages.statusOffline);
+  }
+  const manifest = await loadManifest();
+  const installedRules = manifest ? Object.keys(manifest.rules) : [];
+  if (options.installed) {
+    if (installedRules.length === 0) {
+      log2.info("No rules installed.");
+      return;
+    }
+    console.log("");
+    console.log(formatHeader("Installed Rules"));
+    console.log("");
+    for (const rule of installedRules.sort()) {
+      const entry = manifest.rules[rule];
+      const statusHint = entry.status !== "synced" ? pc4.dim(` (${entry.status})`) : "";
+      console.log(`  ${rule}.md${statusHint}`);
+    }
+  } else {
+    const availableRules = await getAvailableRules(config);
+    if (availableRules.length === 0) {
+      log2.info("No rules found in source.");
+      return;
+    }
+    console.log("");
+    console.log(formatHeader("Available Rules"));
+    console.log("");
+    for (const rule of availableRules.sort((a, b) => a.name.localeCompare(b.name))) {
+      const installed = installedRules.includes(rule.name);
+      const icon = installed ? pc4.green("\u2713") : pc4.dim("\u25CB");
+      const hint = installed ? pc4.dim(" (installed)") : "";
+      console.log(`  ${icon} ${rule.name}.md${hint}`);
+    }
+    console.log("");
+    console.log(pc4.dim(`Source: ${config.source.path}`));
+  }
+  console.log("");
+}
+
+// src/commands/detach.ts
+async function detach(ruleName) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  if (!manifest) {
+    log2.error(messages.noManifest);
+    process.exit(1);
+  }
+  const match = findRuleMatch(ruleName, Object.keys(manifest.rules));
+  if (!match) {
+    log2.error(`Rule '${ruleName}' not found in manifest.`);
+    process.exit(1);
+  }
+  const entry = manifest.rules[match];
+  if (entry.status === "detached") {
+    log2.warn(messages.detachAlready(match));
+    return;
+  }
+  await updateRuleInManifest(match, {
+    status: "detached",
+    detachedAt: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  log2.success(messages.detachSuccess(match));
+}
+
+// src/commands/attach.ts
+import { join as join11 } from "path";
+async function attach(ruleName) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  const manifest = await loadManifest();
+  if (!manifest) {
+    log2.error(messages.noManifest);
+    process.exit(1);
+  }
+  const match = findRuleMatch(ruleName, Object.keys(manifest.rules));
+  if (!match) {
+    log2.error(`Rule '${ruleName}' not found in manifest.`);
+    process.exit(1);
+  }
+  const entry = manifest.rules[match];
+  if (entry.status !== "detached") {
+    log2.warn(messages.attachAlready(match));
+    return;
+  }
+  const claudeDir = getClaudeDir();
+  const filename = getRuleFilename(match);
+  const localPath = join11(claudeDir, filename);
+  const sourcePath = join11(config.source.path, filename);
+  if (!fileExists(sourcePath)) {
+    log2.error(messages.errorMissingSource(match));
+    process.exit(1);
+  }
+  if (!fileExists(localPath)) {
+    log2.error(messages.errorMissingLocal(match));
+    process.exit(1);
+  }
+  const localHash = await hashFile(localPath);
+  const sourceHash = await hashFile(sourcePath);
+  if (localHash === sourceHash) {
+    await updateRuleInManifest(match, {
+      status: "synced",
+      sourceHash,
+      localHash,
+      detachedAt: void 0
+    });
+    log2.success(messages.attachSuccess(match));
+    return;
+  }
+  const action = await handleAttachDiffers(match);
+  if (isCancel2(action)) {
+    log2.info("Cancelled.");
+    return;
+  }
+  switch (action) {
+    case "overwrite":
+      await copyFile(sourcePath, localPath);
+      const newHash = await hashFile(localPath);
+      await updateRuleInManifest(match, {
+        status: "synced",
+        sourceHash,
+        localHash: newHash,
+        detachedAt: void 0
+      });
+      log2.success(messages.attachSuccess(match));
+      break;
+    case "keep":
+      await updateRuleInManifest(match, {
+        status: "diverged",
+        sourceHash,
+        localHash,
+        detachedAt: void 0
+      });
+      log2.success(`${match} attached (will show as diverged)`);
+      break;
+    case "cancel":
+      log2.info("Cancelled.");
+      break;
+  }
+}
+
+// src/commands/source.ts
+import { join as join12 } from "path";
+async function sourceShow() {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  console.log("");
+  console.log(formatHeader("Source Configuration"));
+  console.log("");
+  console.log(`  Type:   ${config.source.type}`);
+  console.log(`  Path:   ${formatPath(config.source.path)}`);
+  if (config.source.remote) {
+    console.log(`  Remote: ${config.source.remote}`);
+  } else if (isGitRepo(config.source.path)) {
+    const remote = await getRemoteUrl(config.source.path);
+    if (remote) {
+      console.log(`  Remote: ${remote}`);
+    }
+  }
+  console.log("");
+  console.log(`  Auto-pull:  ${config.settings.autoPull ? "enabled" : "disabled"}`);
+  console.log(`  Frequency:  ${config.settings.pullFrequency}`);
+  if (config.settings.lastPull) {
+    console.log(`  Last pull:  ${new Date(config.settings.lastPull).toLocaleString()}`);
+  }
+  console.log("");
+}
+async function sourceSet(pathOrUrl) {
+  var _a;
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  if (isGitUrl(pathOrUrl)) {
+    const s = spinner2();
+    s.start("Cloning repository...");
+    const repoName = ((_a = pathOrUrl.split("/").pop()) == null ? void 0 : _a.replace(".git", "")) || "claude-rules";
+    const clonePath = expandTilde(`~/Documents/${repoName}`);
+    try {
+      ensureDir(join12(clonePath, ".."));
+      await cloneRepo(pathOrUrl, clonePath);
+      s.stop("Repository cloned successfully.");
+      config.source = {
+        type: "git",
+        path: clonePath,
+        remote: pathOrUrl
+      };
+    } catch (error) {
+      s.stop("Failed to clone repository.");
+      log2.error(error instanceof Error ? error.message : String(error));
+      process.exit(1);
+    }
+  } else {
+    const expandedPath = expandTilde(pathOrUrl);
+    if (!fileExists(expandedPath)) {
+      log2.error(messages.sourceNotFound(expandedPath));
+      process.exit(1);
+    }
+    config.source = {
+      type: "local",
+      path: expandedPath
+    };
+    if (isGitRepo(expandedPath)) {
+      const remote = await getRemoteUrl(expandedPath);
+      if (remote) {
+        config.source.type = "git";
+        config.source.remote = remote;
+      }
+    }
+  }
+  await saveConfig(config);
+  log2.success(messages.sourceUpdated(config.source.path));
+}
+async function sourcePull() {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  if (!isGitRepo(config.source.path)) {
+    log2.error("Source is not a git repository.");
+    process.exit(1);
+  }
+  if (!await hasRemote(config.source.path)) {
+    log2.error("Source repository has no remote configured.");
+    process.exit(1);
+  }
+  const s = spinner2();
+  s.start("Pulling from remote...");
+  try {
+    await pullRepo(config.source.path);
+    s.stop("Source updated successfully.");
+    config.settings.lastPull = (/* @__PURE__ */ new Date()).toISOString();
+    await saveConfig(config);
+  } catch (error) {
+    s.stop("Failed to pull from remote.");
+    log2.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function sourceConfig(options) {
+  const config = await loadConfig();
+  if (!config) {
+    log2.error(messages.notConfigured);
+    process.exit(1);
+  }
+  if (options.autoPull === void 0 && options.frequency === void 0) {
+    console.log("");
+    console.log(formatHeader("Pull Settings"));
+    console.log("");
+    console.log(`  Auto-pull:  ${config.settings.autoPull ? "enabled" : "disabled"}`);
+    console.log(`  Frequency:  ${config.settings.pullFrequency}`);
+    if (config.settings.lastPull) {
+      console.log(`  Last pull:  ${new Date(config.settings.lastPull).toLocaleString()}`);
+    }
+    console.log("");
+    console.log("  Use --auto-pull and --frequency to change settings.");
+    console.log("");
+    return;
+  }
+  if (options.autoPull !== void 0) {
+    config.settings.autoPull = options.autoPull;
+  }
+  if (options.frequency !== void 0) {
+    config.settings.pullFrequency = options.frequency;
+  }
+  await saveConfig(config);
+  log2.success("Settings updated.");
+  console.log("");
+  console.log(`  Auto-pull:  ${config.settings.autoPull ? "enabled" : "disabled"}`);
+  console.log(`  Frequency:  ${config.settings.pullFrequency}`);
+  console.log("");
+}
+
+// src/commands/doctor.ts
+import { join as join13 } from "path";
+import pc5 from "picocolors";
+async function doctor() {
+  console.log("");
+  console.log(formatHeader("RuleKeeper Diagnostics"));
+  console.log("");
+  const results = [];
+  const configPath = getConfigPath();
+  if (fileExists(configPath)) {
+    results.push({
+      name: "Global config",
+      status: "pass",
+      message: `Found at ${formatPath(configPath)}`
+    });
+  } else {
+    results.push({
+      name: "Global config",
+      status: "fail",
+      message: `Not found. Run ${pc5.cyan("rk init")} to configure.`
+    });
+  }
+  const config = await loadConfig();
+  if (config) {
+    if (fileExists(config.source.path)) {
+      results.push({
+        name: "Source path",
+        status: "pass",
+        message: formatPath(config.source.path)
+      });
+    } else {
+      results.push({
+        name: "Source path",
+        status: "fail",
+        message: `Path does not exist: ${formatPath(config.source.path)}`
+      });
+    }
+    if (fileExists(config.source.path)) {
+      const availableRules = await getAvailableRules(config);
+      if (availableRules.length > 0) {
+        results.push({
+          name: "Source rules",
+          status: "pass",
+          message: `${availableRules.length} rule(s) available`
+        });
+      } else {
+        results.push({
+          name: "Source rules",
+          status: "warn",
+          message: "No .md files found in source"
+        });
+      }
+    }
+    if (config.source.type === "git" && fileExists(config.source.path)) {
+      if (isGitRepo(config.source.path)) {
+        if (await hasRemote(config.source.path)) {
+          results.push({
+            name: "Git remote",
+            status: "pass",
+            message: "Remote configured"
+          });
+        } else {
+          results.push({
+            name: "Git remote",
+            status: "warn",
+            message: "No remote configured - cannot auto-pull"
+          });
+        }
+      } else {
+        results.push({
+          name: "Git repository",
+          status: "fail",
+          message: "Source is configured as git but is not a git repository"
+        });
+      }
+    }
+  }
+  const claudeDir = getClaudeDir();
+  const rulekeeperDir = getRulekeeperDir();
+  if (fileExists(claudeDir)) {
+    results.push({
+      name: ".claude directory",
+      status: "pass",
+      message: "Found in current project"
+    });
+  } else {
+    results.push({
+      name: ".claude directory",
+      status: "warn",
+      message: "Not found - not in a Claude Code project?"
+    });
+  }
+  const manifest = await loadManifest();
+  if (manifest) {
+    const ruleCount = Object.keys(manifest.rules).length;
+    results.push({
+      name: "RuleKeeper manifest",
+      status: "pass",
+      message: `${ruleCount} rule(s) tracked`
+    });
+    if (config && ruleCount > 0) {
+      let missingCount = 0;
+      for (const [ruleName, entry] of Object.entries(manifest.rules)) {
+        const localPath = join13(claudeDir, entry.file);
+        if (!fileExists(localPath)) {
+          missingCount++;
+        }
+      }
+      if (missingCount > 0) {
+        results.push({
+          name: "Rule files",
+          status: "warn",
+          message: `${missingCount} tracked rule(s) missing local files`
+        });
+      } else {
+        results.push({
+          name: "Rule files",
+          status: "pass",
+          message: "All tracked rules have local files"
+        });
+      }
+    }
+  } else if (fileExists(claudeDir)) {
+    results.push({
+      name: "RuleKeeper manifest",
+      status: "warn",
+      message: `No manifest. Run ${pc5.cyan("rk add")} to start tracking rules.`
+    });
+  }
+  let passCount = 0;
+  let warnCount = 0;
+  let failCount = 0;
+  for (const result of results) {
+    let icon;
+    let color;
+    switch (result.status) {
+      case "pass":
+        icon = "\u2713";
+        color = pc5.green;
+        passCount++;
+        break;
+      case "warn":
+        icon = "\u26A0";
+        color = pc5.yellow;
+        warnCount++;
+        break;
+      case "fail":
+        icon = "\u2717";
+        color = pc5.red;
+        failCount++;
+        break;
+    }
+    console.log(`  ${color(icon)} ${result.name}: ${result.message}`);
+  }
+  console.log("");
+  if (failCount > 0) {
+    log2.error(messages.doctorIssuesFound(failCount));
+  } else if (warnCount > 0) {
+    log2.warn(`${warnCount} warning(s) found.`);
+  } else {
+    log2.success(messages.doctorAllGood);
+  }
+}
+
+// src/index.ts
+var program = new Command();
+program.name("rulekeeper").description("Sync and manage Claude Code rules across projects").version("0.1.0");
+program.command("init").description("Interactive global setup").option("-f, --force", "Overwrite existing configuration").action(async (options) => {
+  await init({ force: options.force });
+});
+program.command("add [rules...]").description("Add rules to current project").option("-a, --all", "Add all available rules").action(async (rules, options) => {
+  await add(rules, { all: options.all });
+});
+program.command("remove <rules...>").description("Remove rules from project").option("-k, --keep-file", "Keep the local file, only remove from manifest").action(async (rules, options) => {
+  await remove(rules, { keepFile: options.keepFile });
+});
+program.command("status").description("Show rule states in current project").action(async () => {
+  await status();
+});
+program.command("pull [rules...]").description("Update rules from source").option("-f, --force", "Overwrite diverged rules without prompting").option("--include-detached", "Include detached rules").action(async (rules, options) => {
+  await pull(rules, {
+    force: options.force,
+    includeDetached: options.includeDetached
+  });
+});
+program.command("diff [rule]").description("Show differences between local and source").option("-a, --all", "Show diff for all diverged rules").action(async (rule, options) => {
+  const rules = rule ? [rule] : [];
+  await diff(rules, { all: options.all });
+});
+program.command("list").description("List available rules").option("-i, --installed", "Show only installed rules").action(async (options) => {
+  await list({ installed: options.installed });
+});
+program.command("detach <rule>").description("Mark rule as intentionally diverged").action(async (rule) => {
+  await detach(rule);
+});
+program.command("attach <rule>").description("Resume tracking a detached rule").action(async (rule) => {
+  await attach(rule);
+});
+var sourceCmd = program.command("source").description("Manage source configuration");
+sourceCmd.command("show").description("Show current source configuration").action(async () => {
+  await sourceShow();
+});
+sourceCmd.command("set <path-or-url>").description("Change source location").action(async (pathOrUrl) => {
+  await sourceSet(pathOrUrl);
+});
+sourceCmd.command("pull").description("Manually pull from git remote").action(async () => {
+  await sourcePull();
+});
+sourceCmd.command("config").description("View or update pull settings").option("--auto-pull <boolean>", "Enable or disable auto-pull (on/off)").option("--frequency <freq>", "Set pull frequency (always, daily, weekly)").action(async (options) => {
+  let autoPull;
+  if (options.autoPull !== void 0) {
+    const val = options.autoPull.toLowerCase();
+    if (val === "on" || val === "true" || val === "1") {
+      autoPull = true;
+    } else if (val === "off" || val === "false" || val === "0") {
+      autoPull = false;
+    } else {
+      console.error("Invalid value for --auto-pull. Use: on, off, true, false");
+      process.exit(1);
+    }
+  }
+  let frequency;
+  if (options.frequency !== void 0) {
+    const val = options.frequency.toLowerCase();
+    if (val === "always" || val === "daily" || val === "weekly") {
+      frequency = val;
+    } else {
+      console.error("Invalid value for --frequency. Use: always, daily, weekly");
+      process.exit(1);
+    }
+  }
+  await sourceConfig({ autoPull, frequency });
+});
+program.command("doctor").description("Diagnose setup issues").action(async () => {
+  await doctor();
+});
+program.parse();
+//# sourceMappingURL=index.js.map