@raindogs/contextmd 0.1.0

package/dist/index.js

@@ -0,0 +1,1201 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { program } from "commander";
+import { writeFileSync, existsSync as existsSync5, mkdirSync } from "fs";
+import { join as join5, dirname } from "path";
+import { createInterface } from "readline";
+
+// src/scanner/package.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+function scanPackage(cwd) {
+  const pkgPath = join(cwd, "package.json");
+  if (!existsSync(pkgPath)) {
+    throw new Error("No package.json found. Run contextmd from the root of your project.");
+  }
+  const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
+  const scripts = pkg.scripts ?? {};
+  const allDeps = {
+    ...pkg.dependencies ?? {},
+    ...pkg.devDependencies ?? {},
+    ...pkg.peerDependencies ?? {}
+  };
+  const has = (name) => name in allDeps;
+  const hasPattern = (re) => Object.keys(allDeps).some((k) => re.test(k));
+  let packageManager = "npm";
+  if (existsSync(join(cwd, "bun.lockb"))) packageManager = "bun";
+  else if (existsSync(join(cwd, "pnpm-lock.yaml"))) packageManager = "pnpm";
+  else if (existsSync(join(cwd, "yarn.lock"))) packageManager = "yarn";
+  const runCmd = packageManager === "npm" ? "npm run" : packageManager;
+  let framework;
+  let isNextAppRouter = false;
+  if (has("next")) {
+    framework = "nextjs";
+    isNextAppRouter = existsSync(join(cwd, "app")) || existsSync(join(cwd, "src/app"));
+  } else if (has("react") || has("react-dom")) {
+    framework = "react";
+  } else if (has("vue") || has("@vue/core")) {
+    framework = "vue";
+  } else if (has("@sveltejs/kit") || has("svelte")) {
+    framework = "svelte";
+  } else if (has("express")) {
+    framework = "express";
+  } else if (has("fastify")) {
+    framework = "fastify";
+  } else if (has("hono")) {
+    framework = "hono";
+  }
+  let testRunner;
+  if (has("vitest")) testRunner = "vitest";
+  else if (has("jest") || has("@jest/core") || has("ts-jest")) testRunner = "jest";
+  else if (has("mocha")) testRunner = "mocha";
+  let database;
+  if (has("@prisma/client") || has("prisma")) database = "prisma";
+  else if (has("drizzle-orm")) database = "drizzle";
+  else if (has("@supabase/supabase-js") || has("@supabase/ssr")) database = "supabase";
+  else if (has("mongoose")) database = "mongoose";
+  else if (has("typeorm")) database = "typeorm";
+  else if (has("pg") || has("postgres")) database = "pg";
+  else if (has("better-sqlite3")) database = "better-sqlite3";
+  let stateLib;
+  if (has("zustand")) stateLib = "zustand";
+  else if (has("@reduxjs/toolkit") || has("redux")) stateLib = "redux";
+  else if (has("@tanstack/react-query") || has("@tanstack/query-core")) stateLib = "tanstack-query";
+  else if (has("jotai")) stateLib = "jotai";
+  else if (has("recoil")) stateLib = "recoil";
+  let cssApproach;
+  if (has("tailwindcss")) cssApproach = "tailwind";
+  else if (has("styled-components")) cssApproach = "styled-components";
+  else if (has("@emotion/styled") || has("@emotion/react")) cssApproach = "emotion";
+  else if (has("sass") || has("node-sass")) cssApproach = "sass";
+  let uiLib;
+  if (existsSync(join(cwd, "src/components/ui")) || existsSync(join(cwd, "components/ui"))) {
+    uiLib = "shadcn";
+  } else if (hasPattern(/@radix-ui\//)) {
+    uiLib = "radix";
+  } else if (has("@chakra-ui/react")) {
+    uiLib = "chakra";
+  } else if (has("@mantine/core")) {
+    uiLib = "mantine";
+  } else if (has("@mui/material")) {
+    uiLib = "mui";
+  }
+  const linter = has("eslint") ? "eslint" : has("biome") ? "biome" : void 0;
+  const formatter = has("prettier") ? "prettier" : has("biome") ? "biome" : void 0;
+  let commitConvention;
+  if (has("@commitlint/cli") || has("commitlint") || has("commitizen") || has("@commitlint/config-conventional")) {
+    commitConvention = "conventional-commits";
+  } else if (has("gitmoji-cli")) {
+    commitConvention = "gitmoji";
+  }
+  let deployTarget;
+  if (existsSync(join(cwd, "vercel.json")) || existsSync(join(cwd, ".vercel"))) deployTarget = "vercel";
+  else if (existsSync(join(cwd, "netlify.toml"))) deployTarget = "netlify";
+  else if (existsSync(join(cwd, "fly.toml"))) deployTarget = "fly";
+  else if (existsSync(join(cwd, "Dockerfile")) || existsSync(join(cwd, "docker-compose.yml"))) deployTarget = "docker";
+  let pathAlias;
+  const tsconfigPath = join(cwd, "tsconfig.json");
+  if (existsSync(tsconfigPath)) {
+    try {
+      const tsconfig = JSON.parse(readFileSync(tsconfigPath, "utf-8"));
+      const paths = tsconfig?.compilerOptions?.paths;
+      if (paths) {
+        const aliases = Object.keys(paths);
+        const atAlias = aliases.find((a) => a.startsWith("@/") || a === "@/*");
+        if (atAlias) pathAlias = "@/";
+        else if (aliases.length > 0) pathAlias = aliases[0].replace("/*", "/");
+      }
+    } catch {
+    }
+  }
+  const hasMonorepo = !!(pkg.workspaces || existsSync(join(cwd, "turbo.json")) || existsSync(join(cwd, "nx.json")) || existsSync(join(cwd, "lerna.json")) || existsSync(join(cwd, "pnpm-workspace.yaml")));
+  const hasSupabaseLocal = existsSync(join(cwd, "supabase"));
+  const findScript = (...names) => names.find((n) => n in scripts);
+  const devScript = findScript("dev", "start:dev", "develop");
+  const buildScript = findScript("build", "compile");
+  const testScript = findScript("test", "test:unit", "test:all");
+  const lintScript = findScript("lint", "eslint");
+  const typecheckScript = findScript("typecheck", "type-check", "tsc", "check:types");
+  const formatScript = findScript("format", "fmt", "prettier");
+  const dbMigrateScript = findScript("db:migrate", "db:push", "prisma:migrate", "drizzle-kit:push");
+  const dbGenerateScript = findScript("db:generate", "prisma:generate", "drizzle-kit:generate");
+  const huskyPreCommit = existsSync(join(cwd, ".husky/pre-commit"));
+  let testSingle;
+  if (testRunner === "vitest") testSingle = "vitest run <path/to/file.test.ts>";
+  else if (testRunner === "jest") testSingle = "jest <path/to/file.test.ts>";
+  let preCommit;
+  if (huskyPreCommit) {
+    preCommit = `${runCmd} lint && ${runCmd} typecheck`;
+    if (typecheckScript && lintScript) {
+      preCommit = `${runCmd} ${lintScript} && ${runCmd} ${typecheckScript}`;
+    }
+  } else if (typecheckScript && lintScript) {
+    preCommit = `${runCmd} ${lintScript} && ${runCmd} ${typecheckScript}`;
+  } else if (typecheckScript) {
+    preCommit = `${runCmd} ${typecheckScript}`;
+  }
+  const commands = {
+    dev: devScript ? `${runCmd} ${devScript}` : void 0,
+    build: buildScript ? `${runCmd} ${buildScript}` : void 0,
+    test: testScript ? `${runCmd} ${testScript}` : void 0,
+    testSingle,
+    lint: lintScript ? `${runCmd} ${lintScript}` : void 0,
+    typecheck: typecheckScript ? `${runCmd} ${typecheckScript}` : void 0,
+    format: formatScript ? `${runCmd} ${formatScript}` : void 0,
+    preCommit,
+    dbMigrate: dbMigrateScript ? `${runCmd} ${dbMigrateScript}` : void 0,
+    dbGenerate: dbGenerateScript ? `${runCmd} ${dbGenerateScript}` : void 0
+  };
+  const stack = {
+    framework,
+    language: has("typescript") || existsSync(tsconfigPath) ? "typescript" : "javascript",
+    testRunner,
+    database,
+    stateLib,
+    cssApproach,
+    uiLib,
+    packageManager,
+    linter,
+    formatter,
+    commitConvention,
+    deployTarget,
+    isNextAppRouter,
+    hasMonorepo,
+    hasSupabaseLocal,
+    pathAlias
+  };
+  return {
+    name: pkg.name ?? "untitled",
+    description: pkg.description,
+    version: pkg.version,
+    scripts,
+    allDeps,
+    stack,
+    commands
+  };
+}
+
+// src/scanner/filesystem.ts
+import { readdirSync, statSync, existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join2, relative } from "path";
+var SKIP_ALWAYS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  ".next",
+  ".nuxt",
+  ".svelte-kit",
+  "dist",
+  "build",
+  "out",
+  ".turbo",
+  ".cache",
+  "coverage",
+  ".vercel",
+  ".netlify",
+  "__pycache__",
+  ".pytest_cache"
+]);
+var PURPOSE_MAP = [
+  ["src/app", "App Router pages, layouts, and server components"],
+  ["src/pages", "Next.js pages and API routes"],
+  ["app", "App Router pages, layouts, and server components"],
+  ["pages", "Next.js pages and API routes"],
+  ["src/components", "React components"],
+  ["components", "React components"],
+  ["src/components/ui", "shadcn/ui primitive components"],
+  ["components/ui", "shadcn/ui primitive components"],
+  ["src/lib", "Shared utilities and helper functions"],
+  ["src/utils", "Shared utility functions"],
+  ["lib", "Shared utilities"],
+  ["utils", "Utility functions"],
+  ["src/hooks", "Custom React hooks"],
+  ["hooks", "Custom React hooks"],
+  ["src/types", "TypeScript type definitions"],
+  ["types", "TypeScript type definitions"],
+  ["src/stores", "State management stores"],
+  ["stores", "State management stores"],
+  ["src/server", "Server-side code and API handlers"],
+  ["src/api", "API route handlers"],
+  ["server", "Server-side code"],
+  ["api", "API endpoints"],
+  ["src/db", "Database schema, queries, and migrations"],
+  ["src/database", "Database schema and queries"],
+  ["db", "Database schema and queries"],
+  ["database", "Database layer"],
+  ["supabase", "Supabase local config, migrations, and edge functions"],
+  ["prisma", "Prisma schema and generated client"],
+  ["drizzle", "Drizzle ORM schema and migrations"],
+  ["migrations", "Database migration files"],
+  ["public", "Static assets served as-is"],
+  ["static", "Static assets"],
+  ["assets", "Images, fonts, and other static assets"],
+  ["styles", "Global styles and CSS variables"],
+  ["src/styles", "Global styles"],
+  ["src/config", "App configuration"],
+  ["config", "Configuration files"],
+  ["src/middleware", "Express/Next.js middleware"],
+  ["middleware", "Request middleware"],
+  ["src/services", "Business logic and external service clients"],
+  ["services", "Service layer"],
+  ["src/actions", "Server actions"],
+  ["actions", "Server actions"],
+  ["src/context", "React context providers"],
+  ["context", "React context providers"],
+  ["scripts", "Build and maintenance scripts"],
+  ["tests", "Test files"],
+  ["__tests__", "Test files"],
+  ["e2e", "End-to-end tests"],
+  ["docs", "Documentation"],
+  [".claude", "Claude Code configuration and rules"],
+  [".github", "GitHub Actions and workflows"]
+];
+function getPurpose(relPath) {
+  for (const [key, purpose] of PURPOSE_MAP) {
+    if (typeof key === "string") {
+      if (relPath === key) return purpose;
+    } else {
+      if (key.test(relPath)) return purpose;
+    }
+  }
+  return void 0;
+}
+function inferPurposeFromName(name) {
+  const lower = name.toLowerCase();
+  const map = {
+    scanner: "File and repo analysis modules",
+    generator: "Output generators",
+    generators: "Output generators",
+    parser: "Parsing utilities",
+    parsers: "Parsing utilities",
+    writer: "File writing utilities",
+    writers: "File writing utilities",
+    command: "CLI command handlers",
+    commands: "CLI command handlers",
+    handler: "Request or event handlers",
+    handlers: "Request or event handlers",
+    controller: "Route controllers",
+    controllers: "Route controllers",
+    model: "Data models",
+    models: "Data models",
+    schema: "Data schemas",
+    schemas: "Data schemas",
+    resolver: "GraphQL resolvers",
+    resolvers: "GraphQL resolvers",
+    route: "Route definitions",
+    routes: "Route definitions",
+    plugin: "Plugin modules",
+    plugins: "Plugin modules",
+    provider: "React context providers",
+    providers: "React context providers",
+    helper: "Helper utilities",
+    helpers: "Helper utilities",
+    test: "Test files",
+    tests: "Test files",
+    spec: "Test files",
+    specs: "Test files",
+    fixture: "Test fixtures",
+    fixtures: "Test fixtures",
+    mock: "Mock modules for testing",
+    mocks: "Mock modules for testing",
+    constant: "Constants and enums",
+    constants: "Constants and enums",
+    enum: "TypeScript enums",
+    enums: "TypeScript enums",
+    event: "Event definitions",
+    events: "Event definitions",
+    job: "Background jobs",
+    jobs: "Background jobs",
+    queue: "Job queue definitions",
+    queues: "Job queue definitions",
+    dto: "Data transfer objects",
+    dtos: "Data transfer objects",
+    entity: "Database entities",
+    entities: "Database entities",
+    repository: "Data access repositories",
+    repositories: "Data access repositories"
+  };
+  return map[lower];
+}
+function scanFilesystem(cwd, stack) {
+  const entries = [];
+  const seen = /* @__PURE__ */ new Set();
+  function walk(dir, depth) {
+    if (depth > 3) return;
+    let items;
+    try {
+      items = readdirSync(dir);
+    } catch {
+      return;
+    }
+    for (const item of items) {
+      if (item.startsWith(".") && item !== ".claude" && item !== ".github") continue;
+      if (SKIP_ALWAYS.has(item)) continue;
+      const full = join2(dir, item);
+      const rel = relative(cwd, full);
+      try {
+        const stat = statSync(full);
+        if (!stat.isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (seen.has(rel)) continue;
+      seen.add(rel);
+      const purpose = getPurpose(rel);
+      if (purpose) {
+        entries.push({ path: rel, purpose, isKey: depth <= 2 });
+        continue;
+      }
+      if (item === "src" || item === "packages" || item === "apps" || item === "lib") {
+        walk(full, depth + 1);
+        continue;
+      }
+      if (depth >= 1) {
+        const inferred = inferPurposeFromName(item);
+        if (inferred) {
+          entries.push({ path: rel, purpose: inferred, isKey: true });
+        }
+      }
+    }
+  }
+  walk(cwd, 0);
+  entries.sort((a, b) => {
+    if (a.isKey !== b.isKey) return a.isKey ? -1 : 1;
+    const aDepth = a.path.split("/").length;
+    const bDepth = b.path.split("/").length;
+    if (aDepth !== bDepth) return aDepth - bDepth;
+    return a.path.localeCompare(b.path);
+  });
+  const deduped = [];
+  for (const entry of entries) {
+    const isSubpathOfExisting = deduped.some(
+      (e) => entry.path.startsWith(e.path + "/") && entry.path !== e.path
+    );
+    const isNotable = entry.path.includes("/ui") || entry.path === "supabase" || entry.path.startsWith(".claude");
+    if (!isSubpathOfExisting || isNotable) {
+      deduped.push(entry);
+    }
+  }
+  return deduped.filter((e) => e.isKey).slice(0, 12).concat(deduped.filter((e) => !e.isKey).slice(0, 3)).slice(0, 12);
+}
+function detectMcpServers(cwd) {
+  const servers = [];
+  const claudeDir = join2(cwd, ".claude");
+  if (!existsSync2(claudeDir)) return servers;
+  try {
+    const files = readdirSync(claudeDir);
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      const content = readFileSync2(join2(claudeDir, file), "utf-8");
+      const parsed = JSON.parse(content);
+      if (parsed.mcpServers) {
+        servers.push(...Object.keys(parsed.mcpServers));
+      }
+    }
+  } catch {
+  }
+  const desktopConfig = join2(cwd, "claude_desktop_config.json");
+  if (existsSync2(desktopConfig)) {
+    try {
+      const parsed = JSON.parse(readFileSync2(desktopConfig, "utf-8"));
+      if (parsed.mcpServers) servers.push(...Object.keys(parsed.mcpServers));
+    } catch {
+    }
+  }
+  return [...new Set(servers)];
+}
+
+// src/scanner/git.ts
+import { existsSync as existsSync3 } from "fs";
+import { join as join3 } from "path";
+async function getGit(cwd) {
+  const { simpleGit } = await import("simple-git");
+  return simpleGit(cwd);
+}
+async function scanGit(cwd) {
+  const hasHusky = existsSync3(join3(cwd, ".husky"));
+  if (!existsSync3(join3(cwd, ".git"))) {
+    return { recentExamples: [], hasHusky };
+  }
+  try {
+    const git = await getGit(cwd);
+    const log = await git.log({ maxCount: 25, "--no-merges": null });
+    const messages = log.all.map((c) => c.message.trim()).filter(Boolean);
+    const commitFormat = detectCommitFormat(messages);
+    let defaultBranch;
+    try {
+      const branches = await git.branch(["-r"]);
+      if (branches.all.includes("origin/main")) defaultBranch = "main";
+      else if (branches.all.includes("origin/master")) defaultBranch = "master";
+    } catch {
+    }
+    const recentExamples = pickExamples(messages, commitFormat);
+    return { commitFormat, recentExamples, defaultBranch, hasHusky };
+  } catch {
+    return { recentExamples: [], hasHusky };
+  }
+}
+function detectCommitFormat(messages) {
+  if (messages.length === 0) return void 0;
+  const conventionalRe = /^(feat|fix|chore|docs|style|refactor|perf|test|build|ci|revert)(\(.+\))?: .+/;
+  const conventionalCount = messages.filter((m) => conventionalRe.test(m)).length;
+  const gitmoji = /^[\u{1F300}-\u{1FAFF}]/u;
+  const gitmojiCount = messages.filter((m) => gitmoji.test(m)).length;
+  const threshold = Math.max(3, messages.length * 0.6);
+  if (conventionalCount >= threshold) return "type(scope): description  \u2014 conventional commits";
+  if (gitmojiCount >= threshold) return ":emoji: description  \u2014 gitmoji";
+  return void 0;
+}
+function pickExamples(messages, format) {
+  if (messages.length === 0) return [];
+  if (format?.includes("conventional")) {
+    const types = ["feat", "fix", "chore", "refactor", "docs"];
+    const picked = [];
+    for (const type of types) {
+      const match = messages.find((m) => m.startsWith(type));
+      if (match && picked.length < 3) picked.push(match);
+    }
+    if (picked.length > 0) return picked;
+  }
+  return messages.slice(0, 3);
+}
+
+// src/scanner/inference.ts
+var RULES = [
+  // ── State management ────────────────────────────────────────────────────
+  {
+    condition: (s) => s.stateLib === "zustand",
+    doNot: "Do not introduce Redux or Redux Toolkit \u2014 state management is Zustand",
+    inferredFrom: "dep:zustand"
+  },
+  {
+    condition: (s) => s.stateLib === "tanstack-query",
+    doNot: "Do not store server state in useState or useReducer \u2014 use TanStack Query",
+    inferredFrom: "dep:@tanstack/react-query"
+  },
+  {
+    condition: (s) => s.stateLib === "jotai",
+    doNot: "Do not use Redux or Zustand \u2014 state management is Jotai",
+    inferredFrom: "dep:jotai"
+  },
+  // ── Database ────────────────────────────────────────────────────────────
+  {
+    condition: (s) => s.database === "prisma",
+    doNot: "Do not write raw SQL \u2014 use Prisma ORM for all database access",
+    inferredFrom: "dep:prisma"
+  },
+  {
+    condition: (s) => s.database === "drizzle",
+    doNot: "Do not write raw SQL \u2014 use Drizzle ORM for all database access",
+    inferredFrom: "dep:drizzle-orm"
+  },
+  {
+    condition: (s) => s.database === "supabase",
+    convention: "Use the Supabase client from @/lib/supabase (or equivalent) \u2014 do not instantiate directly",
+    inferredFrom: "dep:@supabase/supabase-js"
+  },
+  // ── CSS / styling ────────────────────────────────────────────────────────
+  {
+    condition: (s) => s.cssApproach === "tailwind",
+    doNot: "Do not use inline styles or CSS-in-JS \u2014 styling is Tailwind utility classes",
+    inferredFrom: "dep:tailwindcss"
+  },
+  {
+    condition: (s) => s.cssApproach === "css-modules",
+    doNot: "Do not use inline styles \u2014 use CSS Modules (*.module.css)",
+    inferredFrom: "css-modules detected"
+  },
+  {
+    condition: (s) => s.cssApproach === "styled-components",
+    convention: "Styling uses styled-components \u2014 keep component styles co-located",
+    inferredFrom: "dep:styled-components"
+  },
+  // ── UI lib ───────────────────────────────────────────────────────────────
+  {
+    condition: (s) => s.uiLib === "shadcn",
+    convention: "UI primitives live in @/components/ui \u2014 use them before creating new components",
+    inferredFrom: "src/components/ui detected"
+  },
+  {
+    condition: (s) => s.uiLib === "chakra",
+    convention: "UI components use Chakra UI \u2014 do not mix with other component libraries",
+    inferredFrom: "dep:@chakra-ui/react"
+  },
+  // ── Next.js ─────────────────────────────────────────────────────────────
+  {
+    condition: (s) => s.isNextAppRouter,
+    convention: 'This is a Next.js App Router project \u2014 use Server Components by default, add "use client" only when needed',
+    inferredFrom: "nextjs app/ directory detected"
+  },
+  {
+    condition: (s) => s.isNextAppRouter,
+    doNot: "Do not create files in a pages/ directory \u2014 this project uses App Router",
+    inferredFrom: "nextjs app/ directory detected"
+  },
+  // ── Path aliases ──────────────────────────────────────────────────────────
+  {
+    condition: (s) => !!s.pathAlias,
+    convention: (s) => `Use the ${s.pathAlias} path alias for imports \u2014 do not use relative paths like ../../`,
+    inferredFrom: "tsconfig paths"
+  },
+  // ── Monorepo ─────────────────────────────────────────────────────────────
+  {
+    condition: (s) => s.hasMonorepo,
+    convention: "Monorepo: run commands from the workspace root with --filter or --workspace flags",
+    inferredFrom: "monorepo config detected"
+  },
+  // ── Commit conventions ───────────────────────────────────────────────────
+  {
+    condition: (s) => s.commitConvention === "conventional-commits",
+    convention: "Commits follow Conventional Commits: type(scope): description (e.g. feat(auth): add OAuth login)",
+    inferredFrom: "dep:@commitlint"
+  },
+  {
+    condition: (s) => s.commitConvention === "gitmoji",
+    convention: "Commits use gitmoji prefix (e.g. \u2728 new feature, \u{1F41B} bug fix)",
+    inferredFrom: "dep:gitmoji-cli"
+  },
+  // ── TypeScript ───────────────────────────────────────────────────────────
+  {
+    condition: (s, deps) => s.language === "typescript" && "typescript" in deps,
+    doNot: "Do not use @ts-ignore or any \u2014 fix type errors properly",
+    inferredFrom: "dep:typescript"
+  },
+  // ── Testing ──────────────────────────────────────────────────────────────
+  {
+    condition: (s) => s.testRunner === "vitest",
+    convention: "Tests use Vitest \u2014 co-locate test files as *.test.ts beside the file they test",
+    inferredFrom: "dep:vitest"
+  }
+];
+function resolveConvention(c, stack) {
+  if (typeof c === "function") return c(stack);
+  return c;
+}
+function inferConventions(stack, allDeps) {
+  const conventions = [];
+  const doNots = [];
+  for (const rule of RULES) {
+    if (!rule.condition(stack, allDeps)) continue;
+    if (rule.convention) {
+      const text = resolveConvention(rule.convention, stack);
+      if (text) conventions.push({ rule: text, inferredFrom: rule.inferredFrom });
+    }
+    if (rule.doNot) {
+      doNots.push(rule.doNot);
+    }
+  }
+  return { conventions, doNots };
+}
+
+// src/scanner/index.ts
+async function scanRepo(cwd) {
+  const pkg = scanPackage(cwd);
+  const [directories, git] = await Promise.all([
+    Promise.resolve(scanFilesystem(cwd, pkg.stack)),
+    scanGit(cwd)
+  ]);
+  const mcpServers = detectMcpServers(cwd);
+  const { conventions, doNots } = inferConventions(pkg.stack, pkg.allDeps);
+  return {
+    name: pkg.name,
+    description: pkg.description,
+    version: pkg.version,
+    stack: pkg.stack,
+    scripts: pkg.scripts,
+    commands: pkg.commands,
+    directories,
+    git,
+    conventions,
+    doNots,
+    mcpServers,
+    hasDatabaseNotes: !!(pkg.stack.database && (pkg.commands.dbMigrate || pkg.stack.hasSupabaseLocal)),
+    hasSupabaseLocal: pkg.stack.hasSupabaseLocal,
+    cwd,
+    allDeps: pkg.allDeps
+  };
+}
+
+// src/generators/claude.ts
+var MAX_LINES = 150;
+function buildHeadline(ctx) {
+  const { stack, name, description } = ctx;
+  const parts = [];
+  if (stack.framework === "nextjs") {
+    parts.push(`Next.js${stack.isNextAppRouter ? " (App Router)" : ""}`);
+  } else if (stack.framework === "react") {
+    parts.push("React");
+  } else if (stack.framework === "vue") {
+    parts.push("Vue");
+  } else if (stack.framework === "svelte") {
+    parts.push("SvelteKit");
+  } else if (stack.framework === "express") {
+    parts.push("Express");
+  } else if (stack.framework === "fastify") {
+    parts.push("Fastify");
+  } else if (stack.framework === "hono") {
+    parts.push("Hono");
+  }
+  if (stack.language === "typescript") parts.push("TypeScript");
+  const keyDeps = [];
+  if (stack.database === "prisma") keyDeps.push("Prisma");
+  else if (stack.database === "drizzle") keyDeps.push("Drizzle");
+  else if (stack.database === "supabase") keyDeps.push("Supabase");
+  if (stack.cssApproach === "tailwind") keyDeps.push("Tailwind");
+  if (stack.uiLib === "shadcn") keyDeps.push("shadcn/ui");
+  if (stack.stateLib === "zustand") keyDeps.push("Zustand");
+  else if (stack.stateLib === "tanstack-query") keyDeps.push("TanStack Query");
+  if (stack.deployTarget === "vercel") keyDeps.push("Vercel");
+  const stackStr = parts.join(" + ");
+  const depsStr = keyDeps.length > 0 ? ` using ${keyDeps.join(", ")}.` : ".";
+  if (description && description.length < 80 && !description.toLowerCase().includes("undefined")) {
+    return `${stackStr}${depsStr} ${description}`;
+  }
+  return `${stackStr}${depsStr}`;
+}
+function buildCommandsSection(ctx) {
+  const lines = ["## Commands", ""];
+  const { commands } = ctx;
+  if (commands.dev) lines.push(`- \`${commands.dev}\` \u2014 start dev server`);
+  if (commands.build) lines.push(`- \`${commands.build}\` \u2014 production build`);
+  if (commands.test) lines.push(`- \`${commands.test}\` \u2014 run all tests`);
+  if (commands.testSingle) lines.push(`- \`${commands.testSingle}\` \u2014 run a single test file`);
+  if (commands.lint) lines.push(`- \`${commands.lint}\` \u2014 lint`);
+  if (commands.typecheck) lines.push(`- \`${commands.typecheck}\` \u2014 type check`);
+  if (commands.format) lines.push(`- \`${commands.format}\` \u2014 format`);
+  if (commands.dbMigrate) lines.push(`- \`${commands.dbMigrate}\` \u2014 run database migrations`);
+  if (commands.dbGenerate) lines.push(`- \`${commands.dbGenerate}\` \u2014 regenerate database types`);
+  if (commands.preCommit) {
+    lines.push("");
+    lines.push(`Always run \`${commands.preCommit}\` before committing.`);
+  }
+  return lines;
+}
+function buildArchSection(ctx) {
+  if (ctx.directories.length === 0) return [];
+  const lines = ["## Architecture", ""];
+  for (const dir of ctx.directories) {
+    lines.push(`- \`${dir.path}/\` \u2014 ${dir.purpose}`);
+  }
+  return lines;
+}
+function buildConventionsSection(ctx) {
+  if (ctx.conventions.length === 0) return [];
+  const lines = ["## Conventions", ""];
+  for (const c of ctx.conventions) {
+    lines.push(`- ${c.rule}`);
+  }
+  return lines;
+}
+function buildTestingSection(ctx) {
+  const { stack, commands } = ctx;
+  if (!stack.testRunner) return [];
+  const lines = ["## Testing", ""];
+  if (stack.testRunner === "vitest") {
+    lines.push(`Uses Vitest. Run all: \`${commands.test ?? "vitest"}\``);
+    if (commands.testSingle) lines.push(`Run one file: \`${commands.testSingle}\``);
+  } else if (stack.testRunner === "jest") {
+    lines.push(`Uses Jest. Run all: \`${commands.test ?? "jest"}\``);
+    if (commands.testSingle) lines.push(`Run one file: \`${commands.testSingle}\``);
+  } else if (stack.testRunner === "mocha") {
+    lines.push(`Uses Mocha. Run: \`${commands.test ?? "mocha"}\``);
+  }
+  return lines;
+}
+function buildGitSection(ctx) {
+  const { git } = ctx;
+  const lines = [];
+  if (!git.commitFormat && git.recentExamples.length === 0) return lines;
+  lines.push("## Git", "");
+  if (git.commitFormat) {
+    lines.push(`Commit format: \`${git.commitFormat}\``);
+  }
+  if (git.recentExamples.length > 0 && git.commitFormat) {
+    lines.push("");
+    lines.push("Examples:");
+    for (const ex of git.recentExamples.slice(0, 2)) {
+      lines.push(`- \`${ex.slice(0, 72)}\``);
+    }
+  }
+  return lines;
+}
+function buildDoNotSection(ctx) {
+  if (ctx.doNots.length === 0) return [];
+  const lines = ["## Do NOT", ""];
+  for (const doNot of ctx.doNots) {
+    lines.push(`- ${doNot}`);
+  }
+  return lines;
+}
+function buildMcpSection(ctx) {
+  if (ctx.mcpServers.length === 0) return [];
+  const lines = ["## MCP Servers", ""];
+  lines.push("Available in this project:");
+  for (const srv of ctx.mcpServers) {
+    lines.push(`- ${srv}`);
+  }
+  return lines;
+}
+function buildDatabaseSection(ctx) {
+  if (!ctx.hasDatabaseNotes) return [];
+  const lines = ["## Database", ""];
+  if (ctx.stack.database === "prisma") {
+    lines.push("Schema is in `prisma/schema.prisma`.");
+    if (ctx.commands.dbMigrate) lines.push(`Run migrations: \`${ctx.commands.dbMigrate}\``);
+    if (ctx.commands.dbGenerate) lines.push(`Regenerate client: \`${ctx.commands.dbGenerate}\``);
+  } else if (ctx.stack.database === "drizzle") {
+    lines.push("Schema is in `drizzle/` or `src/db/`.");
+    if (ctx.commands.dbMigrate) lines.push(`Apply migrations: \`${ctx.commands.dbMigrate}\``);
+  } else if (ctx.stack.hasSupabaseLocal) {
+    lines.push("Uses Supabase local development stack.");
+    lines.push("Start local: `supabase start`");
+    lines.push("Apply migrations: `supabase db push`");
+    if (ctx.commands.dbGenerate) lines.push(`Generate types: \`${ctx.commands.dbGenerate}\``);
+  }
+  return lines;
+}
+function generateClaude(ctx) {
+  const sections = [
+    [`# ${ctx.name}`, "", buildHeadline(ctx), ""],
+    [...buildCommandsSection(ctx), ""],
+    [...buildArchSection(ctx), ""],
+    [...buildConventionsSection(ctx), ""],
+    [...buildTestingSection(ctx), ""],
+    [...buildGitSection(ctx), ""],
+    [...buildDoNotSection(ctx), ""],
+    [...buildMcpSection(ctx), ""],
+    [...buildDatabaseSection(ctx), ""]
+  ];
+  const allLines = sections.flat().join("\n").split("\n");
+  const trimmed = allLines.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  const lines = trimmed.split("\n");
+  if (lines.length <= MAX_LINES) {
+    return trimmed + "\n";
+  }
+  const capped = lines.slice(0, MAX_LINES - 3).join("\n");
+  return capped + "\n\n<!-- contextmd: output capped at 150 lines. Run with --depth for extended output. -->\n";
+}
+
+// src/generators/agents.ts
+function generateAgents(ctx) {
+  const { name, stack, commands, directories, conventions, doNots, git } = ctx;
+  const lines = [];
+  lines.push(`# ${name} \u2014 Agent Instructions`);
+  lines.push("");
+  lines.push(buildHeadline2(ctx));
+  lines.push("");
+  lines.push("## Environment");
+  lines.push("");
+  if (commands.dev) lines.push(`Dev server: \`${commands.dev}\``);
+  if (commands.build) lines.push(`Build: \`${commands.build}\``);
+  if (commands.typecheck) lines.push(`Type check: \`${commands.typecheck}\``);
+  if (commands.lint) lines.push(`Lint: \`${commands.lint}\``);
+  if (commands.test) lines.push(`Tests: \`${commands.test}\``);
+  if (commands.testSingle) lines.push(`Single test: \`${commands.testSingle}\``);
+  lines.push("");
+  lines.push("## Required before completing any task");
+  lines.push("");
+  const checks = [];
+  if (commands.typecheck) checks.push(`Run \`${commands.typecheck}\` \u2014 zero type errors`);
+  if (commands.lint) checks.push(`Run \`${commands.lint}\` \u2014 zero lint errors`);
+  if (commands.test) checks.push(`Run \`${commands.test}\` \u2014 all tests pass`);
+  if (commands.build) checks.push(`Run \`${commands.build}\` \u2014 build succeeds`);
+  if (checks.length > 0) {
+    for (const check of checks) lines.push(`- ${check}`);
+  } else {
+    lines.push("- Ensure no TypeScript errors before submitting");
+    lines.push("- Ensure all existing tests pass");
+  }
+  lines.push("");
+  if (conventions.length > 0) {
+    lines.push("## Code style");
+    lines.push("");
+    for (const c of conventions) {
+      lines.push(`- ${c.rule}`);
+    }
+    lines.push("");
+  }
+  if (doNots.length > 0) {
+    lines.push("## Constraints");
+    lines.push("");
+    for (const doNot of doNots) {
+      lines.push(`- ${doNot}`);
+    }
+    lines.push("");
+  }
+  if (directories.length > 0) {
+    lines.push("## Repository structure");
+    lines.push("");
+    for (const dir of directories) {
+      lines.push(`- \`${dir.path}/\` \u2014 ${dir.purpose}`);
+    }
+    lines.push("");
+  }
+  if (git.commitFormat) {
+    lines.push("## Commit format");
+    lines.push("");
+    lines.push(git.commitFormat);
+    if (git.recentExamples.length > 0) {
+      lines.push("");
+      lines.push("Examples:");
+      for (const ex of git.recentExamples.slice(0, 2)) {
+        lines.push(`- \`${ex.slice(0, 72)}\``);
+      }
+    }
+    lines.push("");
+  }
+  lines.push("## Reminders");
+  lines.push("");
+  if (stack.isNextAppRouter) {
+    lines.push("- This is a Next.js App Router project. Default to Server Components.");
+    lines.push('- Only add "use client" when the component needs browser APIs or event handlers.');
+  }
+  if (stack.database === "prisma") {
+    lines.push("- Never write raw SQL. All database access goes through Prisma.");
+  } else if (stack.database === "drizzle") {
+    lines.push("- Never write raw SQL. All database access goes through Drizzle ORM.");
+  }
+  if (stack.pathAlias) {
+    lines.push(`- Use \`${stack.pathAlias}\` path alias for imports, not relative paths.`);
+  }
+  lines.push("- Do not commit changes to auto-generated files (prisma client, supabase types, etc.).");
+  lines.push("- Prefer editing existing patterns over introducing new abstractions.");
+  return lines.join("\n") + "\n";
+}
+function buildHeadline2(ctx) {
+  const { stack, description } = ctx;
+  const parts = [];
+  if (stack.framework === "nextjs") parts.push(`Next.js${stack.isNextAppRouter ? " App Router" : ""}`);
+  else if (stack.framework === "react") parts.push("React");
+  else if (stack.framework === "vue") parts.push("Vue");
+  else if (stack.framework === "svelte") parts.push("SvelteKit");
+  else if (stack.framework) parts.push(stack.framework);
+  if (stack.language === "typescript") parts.push("TypeScript");
+  const extras = [];
+  if (stack.database === "prisma") extras.push("Prisma");
+  else if (stack.database === "drizzle") extras.push("Drizzle");
+  else if (stack.database === "supabase") extras.push("Supabase");
+  if (stack.cssApproach === "tailwind") extras.push("Tailwind CSS");
+  if (stack.uiLib === "shadcn") extras.push("shadcn/ui");
+  const base = parts.join(" + ") + (extras.length ? ` \xB7 ${extras.join(", ")}` : "");
+  return description ? `${base} \u2014 ${description}` : base;
+}
+
+// src/generators/ruler.ts
+function generateRulerFiles(ctx) {
+  const files = {};
+  files[".ruler/rules.md"] = buildRulerRules(ctx);
+  files[".ruler/project.md"] = buildRulerProject(ctx);
+  return { files };
+}
+function buildRulerRules(ctx) {
+  const lines = [
+    "# Rules",
+    "",
+    "<!-- Generated by contextmd --ruler \u2014 edit here, ruler distributes to all agents -->",
+    ""
+  ];
+  if (ctx.conventions.length > 0) {
+    lines.push("## Conventions", "");
+    for (const c of ctx.conventions) lines.push(`- ${c.rule}`);
+    lines.push("");
+  }
+  if (ctx.doNots.length > 0) {
+    lines.push("## Constraints", "");
+    for (const doNot of ctx.doNots) lines.push(`- ${doNot}`);
+    lines.push("");
+  }
+  if (ctx.commands.preCommit) {
+    lines.push("## Before committing", "", `Always run: \`${ctx.commands.preCommit}\``, "");
+  }
+  return lines.join("\n");
+}
+function buildRulerProject(ctx) {
+  const { name, stack, directories } = ctx;
+  const lines = [`# ${name}`, ""];
+  const parts = [];
+  if (stack.framework) parts.push(stack.framework);
+  if (stack.language === "typescript") parts.push("TypeScript");
+  if (stack.database) parts.push(stack.database);
+  if (parts.length > 0) lines.push(parts.join(" + "), "");
+  if (directories.length > 0) {
+    lines.push("## Structure", "");
+    for (const dir of directories) lines.push(`- \`${dir.path}/\` \u2014 ${dir.purpose}`);
+    lines.push("");
+  }
+  return lines.join("\n");
+}
+
+// src/generators/scorer.ts
+import { readFileSync as readFileSync3, existsSync as existsSync4 } from "fs";
+import { join as join4 } from "path";
+function scoreClaudeFile(cwd) {
+  const filePath = join4(cwd, "CLAUDE.md");
+  if (!existsSync4(filePath)) {
+    return {
+      total: 0,
+      checks: [
+        {
+          name: "File exists",
+          passed: false,
+          score: 0,
+          feedback: "No CLAUDE.md found. Run `npx contextmd` to generate one."
+        }
+      ]
+    };
+  }
+  const content = readFileSync3(filePath, "utf-8");
+  const lines = content.split("\n");
+  const checks = [
+    checkCommands(content),
+    checkArchitecture(content, cwd),
+    checkConventions(content),
+    checkDoNot(content),
+    checkLength(lines)
+  ];
+  const total = Math.round(checks.reduce((sum, c) => sum + c.score, 0));
+  return { total, checks };
+}
+function checkCommands(content) {
+  const hasCommandsSection = /^## Commands/m.test(content);
+  const commandMatches = content.match(/`([^`]+)`/g) ?? [];
+  const hasExecutableCommands = commandMatches.some((cmd) => {
+    const inner = cmd.replace(/`/g, "");
+    return /^(npm|pnpm|yarn|bun|node|npx|vitest|jest|tsc|next|vite|deno)/.test(inner);
+  });
+  const passed = hasCommandsSection && hasExecutableCommands;
+  return {
+    name: "Commands are executable",
+    passed,
+    score: passed ? 20 : hasCommandsSection ? 10 : 0,
+    feedback: passed ? "Commands section has executable commands." : !hasCommandsSection ? "Missing ## Commands section. Add dev, build, test commands." : "Commands section found but commands are not in backtick format."
+  };
+}
+function checkArchitecture(content, cwd) {
+  const hasArchSection = /^## Architecture/m.test(content);
+  if (!hasArchSection) {
+    return {
+      name: "Architecture map",
+      passed: false,
+      score: 0,
+      feedback: "Missing ## Architecture section with directory map."
+    };
+  }
+  const archSection = content.split(/^## /m).find((s) => s.startsWith("Architecture"));
+  const mentionedDirs = (archSection?.match(/`([^`/]+\/[^`]*)`/g) ?? []).map((m) => m.replace(/`/g, "").replace(/\/$/, ""));
+  const existCount = mentionedDirs.filter((d) => {
+    try {
+      return existsSync4(join4(cwd, d));
+    } catch {
+      return false;
+    }
+  }).length;
+  const accuracy = mentionedDirs.length > 0 ? existCount / mentionedDirs.length : 1;
+  const passed = accuracy >= 0.8 || mentionedDirs.length === 0;
+  return {
+    name: "Architecture matches actual structure",
+    passed,
+    score: passed ? 20 : 10,
+    feedback: passed ? "Architecture section looks accurate." : `${mentionedDirs.length - existCount} directories in Architecture section don't exist. Run \`contextmd sync\` to update.`
+  };
+}
+function checkConventions(content) {
+  const hasSection = /^## Conventions/m.test(content);
+  if (!hasSection) {
+    return {
+      name: "Conventions encode team decisions",
+      passed: false,
+      score: 0,
+      feedback: "Missing ## Conventions section. Add at least one non-obvious team decision."
+    };
+  }
+  const section = content.split(/^## /m).find((s) => s.startsWith("Conventions"));
+  const bulletCount = (section?.match(/^- /gm) ?? []).length;
+  const passed = bulletCount >= 1;
+  return {
+    name: "Conventions encode team decisions",
+    passed,
+    score: passed ? 20 : 10,
+    feedback: passed ? `${bulletCount} convention${bulletCount === 1 ? "" : "s"} documented.` : "Conventions section is empty. Add at least one non-obvious team decision."
+  };
+}
+function checkDoNot(content) {
+  const hasSection = /^## Do NOT/m.test(content);
+  if (!hasSection) {
+    return {
+      name: "Do NOT prevents architectural drift",
+      passed: false,
+      score: 0,
+      feedback: "Missing ## Do NOT section. Add 2-3 explicit rejections of plausible alternatives."
+    };
+  }
+  const section = content.split(/^## /m).find((s) => s.startsWith("Do NOT"));
+  const bulletCount = (section?.match(/^- /gm) ?? []).length;
+  const passed = bulletCount >= 1;
+  return {
+    name: "Do NOT prevents architectural drift",
+    passed,
+    score: passed ? 20 : 10,
+    feedback: passed ? `${bulletCount} explicit rejection${bulletCount === 1 ? "" : "s"} documented.` : "Do NOT section is empty. Add explicit rejections of alternatives the team has decided against."
+  };
+}
+function checkLength(lines) {
+  const count = lines.length;
+  const passed = count <= 200;
+  let score;
+  if (count <= 150) score = 20;
+  else if (count <= 200) score = 15;
+  else if (count <= 300) score = 10;
+  else score = 0;
+  return {
+    name: "File under 200 lines",
+    passed,
+    score,
+    feedback: passed ? `${count} lines \u2014 within the 200-line limit.` : `${count} lines \u2014 exceeds 200-line limit. Claude may treat it as low-signal. Trim or move detail to agent_docs/.`
+  };
+}
+
+// src/index.ts
+var VERSION = "0.1.0";
+function write(filePath, content, overwrite = false) {
+  if (!overwrite && existsSync5(filePath)) {
+    console.log(`  \u26A0  ${filePath} already exists \u2014 use --force to overwrite`);
+    return false;
+  }
+  mkdirSync(dirname(filePath), { recursive: true });
+  writeFileSync(filePath, content, "utf-8");
+  return true;
+}
+function lineCount(content) {
+  return content.split("\n").length;
+}
+async function promptSubscribe() {
+  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve) => {
+    rl.question(
+      "\n\u{1F4EC} Get notified about updates? Enter email (or press Enter to skip): ",
+      (email) => {
+        rl.close();
+        if (email && email.includes("@")) {
+          console.log(`  \u2713  Noted \u2014 ${email} will receive release notes`);
+        }
+        resolve();
+      }
+    );
+  });
+}
+program.name("contextmd").description("Generate and sync CLAUDE.md and AGENTS.md for your repo").version(VERSION);
+program.command("init", { isDefault: true }).description("Generate CLAUDE.md and AGENTS.md in the current directory").option("-f, --force", "overwrite existing files").option("--ruler", "also write .ruler/ files for ruler.js fan-out (27+ agent formats)").option("--no-agents", "skip AGENTS.md generation").option("--no-subscribe", "skip the email subscribe prompt").action(async (opts) => {
+  const cwd = process.cwd();
+  let spinner = null;
+  try {
+    const { default: ora } = await import("ora");
+    spinner = ora("Scanning repository...").start();
+  } catch {
+    console.log("Scanning repository...");
+  }
+  let ctx;
+  try {
+    ctx = await scanRepo(cwd);
+    if (spinner) spinner.stop();
+  } catch (err) {
+    if (spinner) spinner.stop();
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error(`
+\u2717  Scan failed: ${msg}`);
+    process.exit(1);
+  }
+  const { default: chalk } = await import("chalk");
+  console.log(`
+${chalk.bold(ctx.name)} \u2014 ${ctx.stack.language}${ctx.stack.framework ? ` / ${ctx.stack.framework}` : ""}`);
+  console.log();
+  const claudeContent = generateClaude(ctx);
+  const claudePath = join5(cwd, "CLAUDE.md");
+  const claudeWritten = write(claudePath, claudeContent, opts.force);
+  if (claudeWritten) {
+    console.log(`  ${chalk.green("\u2713")}  CLAUDE.md  ${chalk.dim(`(${lineCount(claudeContent)} lines)`)}`);
+  }
+  if (opts.agents !== false) {
+    const agentsContent = generateAgents(ctx);
+    const agentsPath = join5(cwd, "AGENTS.md");
+    const agentsWritten = write(agentsPath, agentsContent, opts.force);
+    if (agentsWritten) {
+      console.log(`  ${chalk.green("\u2713")}  AGENTS.md  ${chalk.dim(`(${lineCount(agentsContent)} lines)`)}`);
+    }
+  }
+  if (opts.ruler) {
+    const rulerOutput = generateRulerFiles(ctx);
+    for (const [relPath, content] of Object.entries(rulerOutput.files)) {
+      const fullPath = join5(cwd, relPath);
+      const written = write(fullPath, content, opts.force);
+      if (written) {
+        console.log(`  ${chalk.green("\u2713")}  ${relPath}  ${chalk.dim("(ruler format)")}`);
+      }
+    }
+    console.log();
+    console.log(chalk.dim("  Run `ruler` to distribute rules to all your agent configs."));
+  }
+  console.log();
+  console.log(chalk.dim("  Tip: commit these files \u2014 they improve every AI session on this repo."));
+  console.log(chalk.dim("  Run `contextmd score` to audit the quality of your CLAUDE.md."));
+  if (opts.subscribe !== false) {
+    await promptSubscribe();
+  }
+});
+program.command("sync").description("Regenerate CLAUDE.md and AGENTS.md from current repo state").option("--ruler", "also sync .ruler/ files").action(async (opts) => {
+  const cwd = process.cwd();
+  const hasClaudeFile = existsSync5(join5(cwd, "CLAUDE.md"));
+  const hasAgentsFile = existsSync5(join5(cwd, "AGENTS.md"));
+  if (!hasClaudeFile && !hasAgentsFile) {
+    console.log("No CLAUDE.md or AGENTS.md found. Run `contextmd init` first.");
+    process.exit(1);
+  }
+  console.log("Syncing...");
+  const ctx = await scanRepo(cwd);
+  const { default: chalk } = await import("chalk");
+  if (hasClaudeFile) {
+    const content = generateClaude(ctx);
+    writeFileSync(join5(cwd, "CLAUDE.md"), content, "utf-8");
+    console.log(`  ${chalk.green("\u2713")}  CLAUDE.md updated  ${chalk.dim(`(${lineCount(content)} lines)`)}`);
+  }
+  if (hasAgentsFile) {
+    const content = generateAgents(ctx);
+    writeFileSync(join5(cwd, "AGENTS.md"), content, "utf-8");
+    console.log(`  ${chalk.green("\u2713")}  AGENTS.md updated  ${chalk.dim(`(${lineCount(content)} lines)`)}`);
+  }
+  if (opts.ruler) {
+    const rulerOutput = generateRulerFiles(ctx);
+    for (const [relPath, content] of Object.entries(rulerOutput.files)) {
+      writeFileSync(join5(cwd, relPath), content, "utf-8");
+      console.log(`  ${chalk.green("\u2713")}  ${relPath} updated`);
+    }
+  }
+});
+program.command("score").description("Audit the quality of your CLAUDE.md against the 5 commit-readiness tests").action(async () => {
+  const cwd = process.cwd();
+  const { default: chalk } = await import("chalk");
+  const result = scoreClaudeFile(cwd);
+  console.log(`
+CLAUDE.md quality score: ${chalk.bold(result.total)}/100
+`);
+  for (const check of result.checks) {
+    const icon = check.passed ? chalk.green("\u2713") : chalk.red("\u2717");
+    const scoreStr = chalk.dim(`(${check.score} pts)`);
+    console.log(`  ${icon}  ${check.name} ${scoreStr}`);
+    if (!check.passed) {
+      console.log(`     ${chalk.dim(check.feedback)}`);
+    }
+  }
+  console.log();
+  if (result.total >= 80) {
+    console.log(chalk.green("  Strong CLAUDE.md \u2014 this file is working hard for you."));
+  } else if (result.total >= 60) {
+    console.log(chalk.yellow("  Decent start \u2014 address the failing checks to improve agent accuracy."));
+  } else {
+    console.log(chalk.red("  High risk of Claude ignoring this file. Run `contextmd init --force` to regenerate."));
+  }
+  console.log();
+  console.log(chalk.dim(`  Share your score: "My CLAUDE.md scored ${result.total}/100 with contextmd"`));
+});
+program.parse();
+//# sourceMappingURL=index.js.map