etymd 0.1.0

package/dist/chunk-TCWKIMCU.js

@@ -0,0 +1,502 @@
+#!/usr/bin/env node
+import { VERSION } from './chunk-U33XLT5I.js';
+import { normalizeRelPath, isDirectory, readJson, git, matchesAnyGlob, pathExists, readText } from './chunk-WVYKYPKS.js';
+import path from 'node:path';
+import { promises } from 'node:fs';
+
+// src/pack/version.ts
+var PACK_VERSION = "2";
+var IGNORED_DIRS = /* @__PURE__ */ new Set([
+  "node_modules",
+  ".git",
+  "dist",
+  "build",
+  "coverage",
+  ".next",
+  ".turbo",
+  ".cache",
+  ".pnpm",
+  "out"
+]);
+var MEANINGFUL_DOT_DIRS = /* @__PURE__ */ new Set([
+  ".github",
+  ".gitlab",
+  ".claude",
+  ".cursor",
+  ".githooks",
+  ".husky",
+  ".changeset",
+  ".vscode",
+  ".storybook"
+]);
+async function detectPackageManager(root, pkg) {
+  if (pkg?.packageManager) {
+    const name = pkg.packageManager.split("@")[0];
+    if (name === "pnpm" || name === "yarn" || name === "npm" || name === "bun") return name;
+  }
+  const lock = [
+    ["pnpm-lock.yaml", "pnpm"],
+    ["yarn.lock", "yarn"],
+    ["package-lock.json", "npm"],
+    ["bun.lockb", "bun"]
+  ];
+  for (const [file, pm] of lock) {
+    if (await pathExists(path.join(root, file))) return pm;
+  }
+  return "unknown";
+}
+async function detectWorkspace(root, pkg) {
+  if (await pathExists(path.join(root, "nx.json"))) return { kind: "nx", packageGlobs: [] };
+  if (await pathExists(path.join(root, "turbo.json"))) return { kind: "turbo", packageGlobs: [] };
+  if (await pathExists(path.join(root, "lerna.json"))) return { kind: "lerna", packageGlobs: [] };
+  const pnpmWs = await readText(path.join(root, "pnpm-workspace.yaml"));
+  if (pnpmWs) {
+    const globs = pnpmWs.split("\n").map((l) => l.match(/^\s*-\s*["']?([^"'#]+)["']?/)?.[1]?.trim()).filter((g) => Boolean(g));
+    return { kind: "pnpm", packageGlobs: globs };
+  }
+  if (pkg?.workspaces) {
+    const globs = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces.packages ?? [];
+    return {
+      kind: pkg.packageManager?.startsWith("yarn") ? "yarn" : "npm",
+      packageGlobs: globs
+    };
+  }
+  return { kind: "none", packageGlobs: [] };
+}
+async function listWorkspacePackages(root, globs) {
+  const found = [];
+  const seen = /* @__PURE__ */ new Set();
+  const addFromDir = async (dir) => {
+    const pkgPath = path.join(dir, "package.json");
+    if (seen.has(pkgPath)) return;
+    const pkg = await readJson(pkgPath);
+    if (!pkg?.name) return;
+    seen.add(pkgPath);
+    found.push({
+      name: pkg.name,
+      dir: path.relative(root, dir) || ".",
+      private: Boolean(pkg.private),
+      version: pkg.version
+    });
+  };
+  for (const glob of globs) {
+    const base = glob.replace(/\/\*\*?$/, "");
+    const parent = path.join(root, base);
+    if (!await isDirectory(parent)) continue;
+    let entries;
+    try {
+      entries = await promises.readdir(parent);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (IGNORED_DIRS.has(entry) || entry.startsWith(".")) continue;
+      const child = path.join(parent, entry);
+      if (await isDirectory(child)) await addFromDir(child);
+    }
+  }
+  return found.sort((a, b) => a.dir.localeCompare(b.dir));
+}
+async function expandFileGlobs(root, globs, cap = 500) {
+  if (!globs.length) return [];
+  const out = /* @__PURE__ */ new Set();
+  const walk = async (rel) => {
+    if (out.size >= cap) return;
+    let entries;
+    try {
+      entries = await promises.readdir(path.join(root, rel), { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries) {
+      if (out.size >= cap) return;
+      if (IGNORED_DIRS.has(entry.name)) continue;
+      const child = rel ? `${rel}/${entry.name}` : entry.name;
+      if (entry.isDirectory()) await walk(child);
+      else if (entry.isFile() && matchesAnyGlob(child, globs)) out.add(child);
+    }
+  };
+  const roots = /* @__PURE__ */ new Set();
+  for (const glob of globs) {
+    const segments = normalizeRelPath(glob).split("/");
+    const literal = [];
+    for (const seg of segments) {
+      if (/[*?]/.test(seg)) break;
+      literal.push(seg);
+    }
+    if (literal.length === segments.length) literal.pop();
+    roots.add(literal.join("/"));
+  }
+  const minimal = [...roots].filter(
+    (r) => ![...roots].some((other) => other !== r && (other === "" || r.startsWith(other + "/")))
+  );
+  for (const r of minimal) {
+    if (r && !await isDirectory(path.join(root, r))) continue;
+    await walk(r);
+  }
+  return [...out].sort();
+}
+var isMeta = (value) => /npm-run-all|run-s\b|run-p\b|concurrently|&&/.test(value);
+var ROLE_LADDERS = [
+  {
+    role: "formatCheck",
+    ladder: [
+      (k) => /^format:check$/.test(k),
+      (k) => /^test:format(:local)?$/.test(k),
+      (k) => /^(prettier:check|check:format|format:ci)$/.test(k),
+      (_k, v) => /prettier(\s|.*\s)(-l\b|--check)/.test(v)
+    ]
+  },
+  {
+    role: "typecheck",
+    exclude: /generate|codegen|build|emit|watch/,
+    ladder: [
+      (k) => /^(typecheck|type-check)$/.test(k),
+      (k) => /^test:types(:local)?$/.test(k),
+      (k) => /^(types|check:types|types:check)$/.test(k),
+      (_k, v) => /tsc\b.*--noemit/i.test(v)
+    ]
+  },
+  {
+    role: "test",
+    exclude: /watch|coverage|snapshot|e2e|integration|debug|notsilent|mdx/,
+    ladder: [
+      (k) => /^test:unit(:local|:ci)?$/.test(k),
+      (k) => /^test:jest$/.test(k),
+      (k, v) => /^test$/.test(k) && !isMeta(v),
+      (k) => /^test$/.test(k)
+    ]
+  },
+  {
+    role: "lint",
+    exclude: /fix|format|staged|watch|style/,
+    ladder: [
+      (k) => /^lint$/.test(k),
+      (k) => /^test:lint(:local)?$/.test(k),
+      (k) => /^lint:/.test(k),
+      (_k, v) => /eslint\b/.test(v) && !/--fix/.test(v)
+    ]
+  },
+  {
+    role: "format",
+    exclude: /check|:ci$/,
+    ladder: [
+      (k) => /^format$/.test(k),
+      (k) => /^(format:write|format:prettier|format:fix|prettier)$/.test(k),
+      (_k, v) => /prettier\b.*--write/.test(v)
+    ]
+  },
+  {
+    role: "build",
+    exclude: /watch|storybook/,
+    ladder: [(k) => /^build$/.test(k), (k) => /^build:/.test(k)]
+  },
+  {
+    role: "dev",
+    ladder: [(k) => /^dev$/.test(k), (k) => /^start$/.test(k), (k) => /^dev:/.test(k)]
+  }
+];
+function classifyCommands(scripts = {}) {
+  const out = { raw: scripts };
+  const entries = Object.entries(scripts);
+  for (const { role, exclude, ladder } of ROLE_LADDERS) {
+    for (const pattern of ladder) {
+      const hit = entries.find(([k, v]) => !exclude?.test(k) && pattern(k, v));
+      if (hit) {
+        out[role] = hit[0];
+        break;
+      }
+    }
+  }
+  return out;
+}
+var FRAMEWORK_MARKERS = [
+  ["next", "Next.js"],
+  ["@tanstack/react-start", "TanStack Start"],
+  ["@tanstack/start", "TanStack Start"],
+  ["@tanstack/react-router", "TanStack Router"],
+  ["react", "React"],
+  ["vue", "Vue"],
+  ["svelte", "Svelte"],
+  ["@angular/core", "Angular"],
+  ["express", "Express"],
+  ["fastify", "Fastify"],
+  ["@nestjs/core", "NestJS"],
+  ["@trpc/server", "tRPC"],
+  ["vite", "Vite"],
+  ["react-scripts", "CRA"],
+  ["@apollo/client", "Apollo"],
+  ["drizzle-orm", "Drizzle"],
+  ["prisma", "Prisma"],
+  ["@sanity/client", "Sanity"],
+  ["nx", "Nx"]
+];
+function detectFrameworks(pkg) {
+  if (!pkg) return [];
+  const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+  const out = [];
+  for (const [marker, label] of FRAMEWORK_MARKERS) {
+    if (deps[marker] && !out.includes(label)) out.push(label);
+  }
+  return out;
+}
+async function detectCi(root) {
+  if (await pathExists(path.join(root, ".gitlab-ci.yml"))) {
+    return { system: "gitlab", files: [".gitlab-ci.yml"] };
+  }
+  const workflows = path.join(root, ".github", "workflows");
+  if (await isDirectory(workflows)) {
+    try {
+      const files = (await promises.readdir(workflows)).filter((f) => f.endsWith(".yml") || f.endsWith(".yaml")).map((f) => path.join(".github/workflows", f));
+      if (files.length) return { system: "github", files };
+    } catch {
+    }
+  }
+  return { system: "none", files: [] };
+}
+async function hasLintStagedConfig(root, pkg) {
+  if (pkg && pkg["lint-staged"]) return true;
+  for (const f of [
+    ".lintstagedrc",
+    ".lintstagedrc.json",
+    ".lintstagedrc.js",
+    "lint-staged.config.js"
+  ]) {
+    if (await pathExists(path.join(root, f))) return true;
+  }
+  return false;
+}
+async function detectHooks(root, hooksPath, pkg) {
+  const lintStaged = await hasLintStagedConfig(root, pkg);
+  if (hooksPath) {
+    if (hooksPath.replace(/\/+$/, "") === ".husky/_") {
+      const base2 = path.join(root, ".husky");
+      return {
+        source: "husky",
+        dir: ".husky",
+        preCommit: await pathExists(path.join(base2, "pre-commit")),
+        prePush: await pathExists(path.join(base2, "pre-push")),
+        commitMsg: await pathExists(path.join(base2, "commit-msg")),
+        lintStaged
+      };
+    }
+    const base = path.join(root, hooksPath);
+    return {
+      source: hooksPath === ".githooks" ? "githooks" : "custom",
+      dir: hooksPath,
+      preCommit: await pathExists(path.join(base, "pre-commit")),
+      prePush: await pathExists(path.join(base, "pre-push")),
+      commitMsg: await pathExists(path.join(base, "commit-msg")),
+      lintStaged
+    };
+  }
+  if (await isDirectory(path.join(root, ".githooks"))) {
+    const base = path.join(root, ".githooks");
+    return {
+      source: "githooks",
+      dir: ".githooks",
+      preCommit: await pathExists(path.join(base, "pre-commit")),
+      prePush: await pathExists(path.join(base, "pre-push")),
+      commitMsg: await pathExists(path.join(base, "commit-msg")),
+      lintStaged
+    };
+  }
+  if (await isDirectory(path.join(root, ".husky"))) {
+    const base = path.join(root, ".husky");
+    return {
+      source: "husky",
+      dir: ".husky",
+      preCommit: await pathExists(path.join(base, "pre-commit")),
+      prePush: await pathExists(path.join(base, "pre-push")),
+      commitMsg: await pathExists(path.join(base, "commit-msg")),
+      lintStaged
+    };
+  }
+  const legacyHooks = pkg?.husky?.hooks;
+  const configText = legacyHooks ? null : await readText(path.join(root, "husky.config.js"));
+  if (legacyHooks || configText) {
+    const hookNamed = (name) => legacyHooks ? Boolean(legacyHooks[name]) : Boolean(configText && configText.includes(name));
+    return {
+      source: "husky-legacy",
+      preCommit: hookNamed("pre-commit"),
+      prePush: hookNamed("pre-push"),
+      commitMsg: hookNamed("commit-msg"),
+      lintStaged
+    };
+  }
+  return { source: "none", preCommit: false, prePush: false, commitMsg: false, lintStaged };
+}
+var ARTIFACT_SPECS = [
+  { id: "agents", label: "AGENTS.md (operating contract)", path: "AGENTS.md", kind: "contract" },
+  {
+    id: "project-context",
+    label: "PROJECT_CONTEXT.md (ground-truth state)",
+    path: "PROJECT_CONTEXT.md",
+    kind: "state"
+  },
+  { id: "claude", label: "CLAUDE.md (Claude Code pointer)", path: "CLAUDE.md", kind: "adapter" },
+  {
+    id: "copilot",
+    label: "Copilot instructions",
+    path: ".github/copilot-instructions.md",
+    kind: "adapter"
+  },
+  {
+    id: "cursorrules",
+    label: ".cursorrules (legacy Cursor)",
+    path: ".cursorrules",
+    kind: "adapter"
+  },
+  { id: "cursor-rules", label: ".cursor/rules", path: ".cursor/rules", kind: "adapter" },
+  { id: "gemini", label: "GEMINI.md", path: "GEMINI.md", kind: "adapter" },
+  { id: "cline", label: ".clinerules", path: ".clinerules", kind: "adapter" },
+  { id: "windsurf", label: ".windsurfrules", path: ".windsurfrules", kind: "adapter" },
+  { id: "skills", label: "Agent skills (.claude/skills)", path: ".claude/skills", kind: "skill" },
+  {
+    id: "failure-modes-skill",
+    label: "Failure-modes register (skill)",
+    path: ".claude/skills/failure-modes",
+    kind: "skill"
+  },
+  {
+    id: "failure-modes-doc",
+    label: "Failure-modes register (doc)",
+    path: "docs/failure-modes.md",
+    kind: "other"
+  },
+  {
+    id: "sessions",
+    label: "Session archive (docs/sessions)",
+    path: "docs/sessions",
+    kind: "sessions"
+  },
+  { id: "githooks", label: "Tracked git hooks (.githooks)", path: ".githooks", kind: "gate" },
+  {
+    id: "inventory",
+    label: "Reuse inventory (docs/INVENTORY.md)",
+    path: "docs/INVENTORY.md",
+    kind: "map"
+  }
+];
+async function detectArtifacts(root) {
+  return Promise.all(
+    ARTIFACT_SPECS.map(async (spec) => ({
+      ...spec,
+      exists: await pathExists(path.join(root, spec.path))
+    }))
+  );
+}
+async function walkTree(root) {
+  const state = { budget: 2e4, truncated: false };
+  const countFiles = async (dir) => {
+    if (state.budget <= 0) {
+      state.truncated = true;
+      return 0;
+    }
+    let total = 0;
+    let entries;
+    try {
+      entries = await promises.readdir(dir, { withFileTypes: true });
+    } catch {
+      return 0;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith(".") || IGNORED_DIRS.has(entry.name)) continue;
+      if (entry.isDirectory()) {
+        total += await countFiles(path.join(dir, entry.name));
+      } else if (entry.isFile()) {
+        total += 1;
+        state.budget -= 1;
+        if (state.budget <= 0) {
+          state.truncated = true;
+          break;
+        }
+      }
+    }
+    return total;
+  };
+  let top;
+  try {
+    top = await promises.readdir(root, { withFileTypes: true });
+  } catch {
+    return { dirs: [], truncated: false };
+  }
+  const dirs = [];
+  for (const entry of top) {
+    if (!entry.isDirectory()) continue;
+    if (IGNORED_DIRS.has(entry.name)) continue;
+    if (entry.name.startsWith(".") && !MEANINGFUL_DOT_DIRS.has(entry.name)) continue;
+    dirs.push({ name: entry.name, files: await countFiles(path.join(root, entry.name)) });
+  }
+  dirs.sort((a, b) => b.files - a.files);
+  return { dirs, truncated: state.truncated };
+}
+
+// src/core/scan.ts
+function inferTicketKey(subjects) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const m of subjects.matchAll(/\b([A-Z][A-Z0-9]{1,9})-\d+\b/g)) {
+    const key = m[1];
+    counts.set(key, (counts.get(key) ?? 0) + 1);
+  }
+  let best;
+  let bestCount = 0;
+  for (const [key, count] of counts) {
+    if (count > bestCount) {
+      best = key;
+      bestCount = count;
+    }
+  }
+  return bestCount >= 3 ? best : void 0;
+}
+async function scanProject(root) {
+  const abs = path.resolve(root);
+  const rootPkg = await readJson(path.join(abs, "package.json"));
+  const [packageManager, workspace, ci, artifacts, tree, isRepo] = await Promise.all([
+    detectPackageManager(abs, rootPkg),
+    detectWorkspace(abs, rootPkg),
+    detectCi(abs),
+    detectArtifacts(abs),
+    walkTree(abs),
+    git(abs, ["rev-parse", "--is-inside-work-tree"]).then((r) => r === "true")
+  ]);
+  const [branch, head, hooksPathRaw, authorsRaw, subjectsRaw] = isRepo ? await Promise.all([
+    git(abs, ["rev-parse", "--abbrev-ref", "HEAD"]),
+    git(abs, ["rev-parse", "--short", "HEAD"]),
+    git(abs, ["config", "--get", "core.hooksPath"]),
+    git(abs, ["log", "-200", "--format=%ae"]),
+    git(abs, ["log", "-50", "--format=%s"])
+  ]) : [null, null, null, null, null];
+  const hooksPath = hooksPathRaw ?? void 0;
+  const hooks = await detectHooks(abs, hooksPath, rootPkg);
+  const packages = workspace.packageGlobs.length ? await listWorkspacePackages(abs, workspace.packageGlobs) : [];
+  const recentAuthors = authorsRaw ? new Set(authorsRaw.split("\n").filter(Boolean)).size : void 0;
+  return {
+    etymdVersion: VERSION,
+    packVersion: PACK_VERSION,
+    generatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    root: abs,
+    name: rootPkg?.name ?? path.basename(abs),
+    git: {
+      isRepo,
+      branch: branch ?? void 0,
+      head: head ?? void 0,
+      hooksPath,
+      husky: hooks.source === "husky" || hooks.source === "husky-legacy",
+      recentAuthors,
+      ticketKey: subjectsRaw ? inferTicketKey(subjectsRaw) : void 0
+    },
+    packageManager,
+    node: rootPkg?.engines?.node,
+    workspace: { kind: workspace.kind, packageGlobs: workspace.packageGlobs },
+    packages,
+    frameworks: detectFrameworks(rootPkg),
+    commands: classifyCommands(rootPkg?.scripts),
+    ci,
+    hooks,
+    artifacts,
+    tree
+  };
+}
+
+export { PACK_VERSION, expandFileGlobs, scanProject };

package/dist/chunk-U33XLT5I.js

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+// package.json
+var package_default = {
+  version: "0.1.0"};
+
+// src/version.ts
+var VERSION = package_default.version;
+
+export { VERSION };