codealmanac 0.2.5 → 0.2.7

package/dist/{chunk-KQUVMF27.js → chunk-BFIG2CXM.js}

@@ -1,17 +1,4 @@
 #!/usr/bin/env node
-import {
-  BLUE,
-  BOLD,
-  DIM,
-  GREEN,
-  RED,
-  RST
-} from "./chunk-FM3VRDK7.js";
-import {
-  findNearestAlmanacDir,
-  getGlobalAlmanacDir,
-  getRegistryPath
-} from "./chunk-7JUX4ADQ.js";
 
 // src/indexer/schema.ts
 import Database from "better-sqlite3";
@@ -724,497 +711,6 @@ function hashContent(raw) {
   return createHash("sha256").update(raw).digest("hex");
 }
 
-// src/registry/index.ts
-import { mkdir as mkdir2, readFile as readFile3, rename as rename2, writeFile as writeFile2 } from "fs/promises";
-import { dirname as dirname2 } from "path";
-async function readRegistry() {
-  const path = getRegistryPath();
-  let raw;
-  try {
-    raw = await readFile3(path, "utf8");
-  } catch (err) {
-    if (isNodeError2(err) && err.code === "ENOENT") {
-      return [];
-    }
-    throw err;
-  }
-  const trimmed = raw.trim();
-  if (trimmed.length === 0) {
-    return [];
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(trimmed);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    throw new Error(`registry at ${path} is not valid JSON: ${message}`);
-  }
-  if (!Array.isArray(parsed)) {
-    throw new Error(`registry at ${path} must be a JSON array`);
-  }
-  return parsed.map((item, idx) => {
-    if (typeof item !== "object" || item === null) {
-      throw new Error(`registry entry ${idx} is not an object`);
-    }
-    const e = item;
-    const name = typeof e.name === "string" ? e.name : "";
-    const path2 = typeof e.path === "string" ? e.path : "";
-    if (name.length === 0) {
-      throw new Error(`registry entry ${idx} is missing a non-empty "name"`);
-    }
-    if (path2.length === 0) {
-      throw new Error(`registry entry ${idx} is missing a non-empty "path"`);
-    }
-    return {
-      name,
-      description: typeof e.description === "string" ? e.description : "",
-      path: path2,
-      registered_at: typeof e.registered_at === "string" ? e.registered_at : ""
-    };
-  });
-}
-async function writeRegistry(entries) {
-  const path = getRegistryPath();
-  await mkdir2(dirname2(path), { recursive: true });
-  const body = `${JSON.stringify(entries, null, 2)}
-`;
-  const tmpPath = `${path}.tmp`;
-  await writeFile2(tmpPath, body, "utf8");
-  await rename2(tmpPath, path);
-}
-function pathsEqual(a, b) {
-  if (process.platform === "darwin" || process.platform === "win32") {
-    return a.toLowerCase() === b.toLowerCase();
-  }
-  return a === b;
-}
-async function addEntry(entry) {
-  const existing = await readRegistry();
-  const filtered = existing.filter(
-    (e) => e.name !== entry.name && !pathsEqual(e.path, entry.path)
-  );
-  filtered.push(entry);
-  await writeRegistry(filtered);
-  return filtered;
-}
-async function dropEntry(name) {
-  const existing = await readRegistry();
-  const idx = existing.findIndex((e) => e.name === name);
-  if (idx === -1) {
-    return null;
-  }
-  const [removed] = existing.splice(idx, 1);
-  await writeRegistry(existing);
-  return removed ?? null;
-}
-async function findEntry(params) {
-  const entries = await readRegistry();
-  for (const entry of entries) {
-    if (params.name !== void 0 && entry.name === params.name) return entry;
-    if (params.path !== void 0 && pathsEqual(entry.path, params.path)) {
-      return entry;
-    }
-  }
-  return null;
-}
-async function ensureGlobalDir() {
-  await mkdir2(getGlobalAlmanacDir(), { recursive: true });
-}
-function isNodeError2(err) {
-  return err instanceof Error && "code" in err;
-}
-
-// src/commands/health.ts
-import { existsSync as existsSync6 } from "fs";
-import { readFile as readFile4 } from "fs/promises";
-import { basename as basename2, join as join4 } from "path";
-import fg3 from "fast-glob";
-
-// src/indexer/duration.ts
-function parseDuration(input) {
-  const trimmed = input.trim();
-  const m = trimmed.match(/^(\d+)([mhdw])$/);
-  if (m === null) {
-    throw new Error(
-      `invalid duration "${input}" (expected Nw, Nd, Nh, or Nm \u2014 e.g. 2w, 30d)`
-    );
-  }
-  const n = Number.parseInt(m[1] ?? "0", 10);
-  const unit = m[2];
-  switch (unit) {
-    case "m":
-      return n * 60;
-    case "h":
-      return n * 60 * 60;
-    case "d":
-      return n * 60 * 60 * 24;
-    case "w":
-      return n * 60 * 60 * 24 * 7;
-    default:
-      throw new Error(`invalid duration unit "${unit ?? ""}"`);
-  }
-}
-
-// src/indexer/resolve-wiki.ts
-import { existsSync as existsSync5 } from "fs";
-import { join as join3 } from "path";
-async function resolveWikiRoot(params) {
-  if (params.wiki !== void 0) {
-    const entry = await findEntry({ name: params.wiki });
-    if (entry === null) {
-      throw new Error(`no registered wiki named "${params.wiki}"`);
-    }
-    if (!existsSync5(join3(entry.path, ".almanac"))) {
-      throw new Error(
-        `wiki "${params.wiki}" path is unreachable (${entry.path})`
-      );
-    }
-    return entry.path;
-  }
-  const nearest = findNearestAlmanacDir(params.cwd);
-  if (nearest === null) {
-    throw new Error(
-      "no .almanac/ found in this directory or any parent; run `almanac bootstrap` first"
-    );
-  }
-  return nearest;
-}
-
-// src/topics/dag.ts
-var DAG_DEPTH_CAP = 32;
-function ancestorsInFile(file, slug) {
-  const parentsOf = /* @__PURE__ */ new Map();
-  for (const t of file.topics) {
-    parentsOf.set(t.slug, t.parents);
-  }
-  const ancestors = /* @__PURE__ */ new Set();
-  let frontier = parentsOf.get(slug) ?? [];
-  let depth = 0;
-  while (frontier.length > 0 && depth < DAG_DEPTH_CAP) {
-    const next = [];
-    for (const node of frontier) {
-      if (ancestors.has(node)) continue;
-      ancestors.add(node);
-      const ps = parentsOf.get(node);
-      if (ps !== void 0) next.push(...ps);
-    }
-    frontier = next;
-    depth += 1;
-  }
-  return ancestors;
-}
-function descendantsInDb(db, slug) {
-  const rows = db.prepare(
-    `WITH RECURSIVE desc(slug, depth) AS (
-         SELECT child_slug, 1 FROM topic_parents WHERE parent_slug = ?
-         UNION
-         SELECT tp.child_slug, d.depth + 1
-         FROM topic_parents tp
-         JOIN desc d ON tp.parent_slug = d.slug
-         WHERE d.depth < ?
-       )
-       SELECT DISTINCT slug FROM desc ORDER BY slug`
-  ).all(slug, DAG_DEPTH_CAP).map((r) => r.slug);
-  return rows;
-}
-function subtreeInDb(db, slug) {
-  return [slug, ...descendantsInDb(db, slug)];
-}
-
-// src/commands/health.ts
-var DEFAULT_STALE_SECONDS = 90 * 24 * 60 * 60;
-async function runHealth(options) {
-  const repoRoot = await resolveWikiRoot({ cwd: options.cwd, wiki: options.wiki });
-  await ensureFreshIndex({ repoRoot });
-  const almanacDir = join4(repoRoot, ".almanac");
-  const pagesDir = join4(almanacDir, "pages");
-  const db = openIndex(join4(almanacDir, "index.db"));
-  try {
-    const staleSeconds = options.stale !== void 0 ? parseDuration(options.stale) : DEFAULT_STALE_SECONDS;
-    const scope = resolveScope(db, options);
-    const report = {
-      orphans: findOrphans(db, scope),
-      stale: findStale(db, scope, staleSeconds),
-      dead_refs: await findDeadRefs(db, scope, repoRoot),
-      broken_links: findBrokenLinks(db, scope),
-      broken_xwiki: await findBrokenXwiki(db, scope),
-      empty_topics: findEmptyTopics(db, scope),
-      empty_pages: await findEmptyPages(db, scope, pagesDir),
-      slug_collisions: await findSlugCollisions(pagesDir)
-    };
-    if (options.json === true) {
-      return {
-        stdout: `${JSON.stringify(report, null, 2)}
-`,
-        stderr: "",
-        exitCode: 0
-      };
-    }
-    return {
-      stdout: formatReport(report),
-      stderr: "",
-      exitCode: 0
-    };
-  } finally {
-    db.close();
-  }
-}
-function resolveScope(db, options) {
-  let pages = null;
-  let topics = null;
-  if (options.topic !== void 0) {
-    const rootSlug = toKebabCase(options.topic);
-    if (rootSlug.length > 0) {
-      const subtree = subtreeInDb(db, rootSlug);
-      topics = new Set(subtree);
-      const placeholders = subtree.map(() => "?").join(", ");
-      const rows = db.prepare(
-        `SELECT DISTINCT page_slug FROM page_topics
-           WHERE topic_slug IN (${placeholders})`
-      ).all(...subtree);
-      pages = new Set(rows.map((r) => r.page_slug));
-    }
-  }
-  if (options.stdin === true && options.stdinInput !== void 0) {
-    const stdinPages = /* @__PURE__ */ new Set();
-    for (const line of options.stdinInput.split(/\r?\n/)) {
-      const s = line.trim();
-      if (s.length > 0) stdinPages.add(s);
-    }
-    if (pages === null) pages = stdinPages;
-    else {
-      const out = /* @__PURE__ */ new Set();
-      for (const s of stdinPages) if (pages.has(s)) out.add(s);
-      pages = out;
-    }
-  }
-  return { pages, topics };
-}
-function inPageScope(scope, slug) {
-  if (scope.pages === null) return true;
-  return scope.pages.has(slug);
-}
-function findOrphans(db, scope) {
-  const rows = db.prepare(
-    `SELECT p.slug FROM pages p
-       WHERE p.archived_at IS NULL
-         AND NOT EXISTS (
-           SELECT 1 FROM page_topics pt WHERE pt.page_slug = p.slug
-         )
-       ORDER BY p.slug`
-  ).all();
-  return rows.filter((r) => inPageScope(scope, r.slug));
-}
-function findStale(db, scope, staleSeconds) {
-  const now = Math.floor(Date.now() / 1e3);
-  const threshold = now - staleSeconds;
-  const rows = db.prepare(
-    `SELECT slug, updated_at FROM pages
-       WHERE archived_at IS NULL AND updated_at < ?
-       ORDER BY updated_at ASC`
-  ).all(threshold);
-  return rows.filter((r) => inPageScope(scope, r.slug)).map((r) => ({
-    slug: r.slug,
-    days_since_update: Math.floor((now - r.updated_at) / (60 * 60 * 24))
-  }));
-}
-async function findDeadRefs(db, scope, repoRoot) {
-  const rows = db.prepare(
-    `SELECT p.slug, r.path, r.original_path, r.is_dir
-       FROM file_refs r
-       JOIN pages p ON p.slug = r.page_slug
-       WHERE p.archived_at IS NULL
-       ORDER BY p.slug, r.path`
-  ).all();
-  const out = [];
-  for (const r of rows) {
-    if (!inPageScope(scope, r.slug)) continue;
-    const abs = join4(repoRoot, r.original_path);
-    if (!existsSync6(abs)) {
-      out.push({ slug: r.slug, path: r.original_path });
-    }
-  }
-  return out;
-}
-function findBrokenLinks(db, scope) {
-  const rows = db.prepare(
-    `SELECT w.source_slug, w.target_slug
-       FROM wikilinks w
-       JOIN pages src ON src.slug = w.source_slug
-       LEFT JOIN pages tgt ON tgt.slug = w.target_slug
-       WHERE tgt.slug IS NULL AND src.archived_at IS NULL
-       ORDER BY w.source_slug, w.target_slug`
-  ).all();
-  return rows.filter((r) => inPageScope(scope, r.source_slug));
-}
-async function findBrokenXwiki(db, scope) {
-  const rows = db.prepare(
-    // Same archived-source filter as `findBrokenLinks`. Retired pages
-    // shouldn't spam the report with links to wikis that may have
-    // been intentionally retired too.
-    `SELECT x.source_slug, x.target_wiki, x.target_slug
-       FROM cross_wiki_links x
-       JOIN pages src ON src.slug = x.source_slug
-       WHERE src.archived_at IS NULL
-       ORDER BY x.source_slug, x.target_wiki, x.target_slug`
-  ).all();
-  const out = [];
-  const reachableCache = /* @__PURE__ */ new Map();
-  for (const r of rows) {
-    if (!inPageScope(scope, r.source_slug)) continue;
-    let ok = reachableCache.get(r.target_wiki);
-    if (ok === void 0) {
-      const entry = await findEntry({ name: r.target_wiki });
-      ok = entry !== null && existsSync6(join4(entry.path, ".almanac"));
-      reachableCache.set(r.target_wiki, ok);
-    }
-    if (!ok) {
-      out.push({
-        source_slug: r.source_slug,
-        target_wiki: r.target_wiki,
-        target_slug: r.target_slug
-      });
-    }
-  }
-  return out;
-}
-function findEmptyTopics(db, scope) {
-  const rows = db.prepare(
-    `SELECT t.slug FROM topics t
-       WHERE NOT EXISTS (
-         SELECT 1 FROM page_topics pt WHERE pt.topic_slug = t.slug
-       )
-       ORDER BY t.slug`
-  ).all();
-  if (scope.topics === null) return rows;
-  return rows.filter((r) => scope.topics.has(r.slug));
-}
-async function findEmptyPages(db, scope, pagesDir) {
-  const rows = db.prepare(
-    `SELECT slug, file_path FROM pages
-       WHERE archived_at IS NULL
-       ORDER BY slug`
-  ).all();
-  const out = [];
-  for (const r of rows) {
-    if (!inPageScope(scope, r.slug)) continue;
-    let raw;
-    try {
-      raw = await readFile4(r.file_path, "utf8");
-    } catch {
-      continue;
-    }
-    const m = raw.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n?([\s\S]*)$/);
-    const body = m !== null ? m[1] ?? "" : raw;
-    void pagesDir;
-    const hasSubstance = body.split(/\r?\n/).some((l) => {
-      const t = l.trim();
-      if (t.length === 0) return false;
-      if (t.startsWith("#")) return false;
-      return true;
-    });
-    if (!hasSubstance) {
-      out.push({ slug: r.slug });
-    }
-  }
-  return out;
-}
-async function findSlugCollisions(pagesDir) {
-  if (!existsSync6(pagesDir)) return [];
-  const files = await fg3("**/*.md", {
-    cwd: pagesDir,
-    absolute: false,
-    onlyFiles: true,
-    caseSensitiveMatch: true
-  });
-  const bySlug = /* @__PURE__ */ new Map();
-  for (const rel of files) {
-    const slug = toKebabCase(basename2(rel, ".md"));
-    if (slug.length === 0) continue;
-    const list = bySlug.get(slug) ?? [];
-    list.push(rel);
-    bySlug.set(slug, list);
-  }
-  const out = [];
-  for (const [slug, paths] of bySlug.entries()) {
-    if (paths.length > 1) {
-      out.push({ slug, paths: paths.sort() });
-    }
-  }
-  out.sort((a, b) => a.slug.localeCompare(b.slug));
-  return out;
-}
-function formatReport(r) {
-  const sections = [];
-  sections.push(
-    section(
-      "orphans",
-      r.orphans.length,
-      r.orphans.map((o) => `  ${BLUE}${o.slug}${RST}`)
-    )
-  );
-  sections.push(
-    section(
-      "stale",
-      r.stale.length,
-      r.stale.map((s) => `  ${BLUE}${s.slug}${RST}     ${DIM}(${s.days_since_update} days)${RST}`)
-    )
-  );
-  sections.push(
-    section(
-      "dead-refs",
-      r.dead_refs.length,
-      r.dead_refs.map((d) => `  ${BLUE}${d.slug}${RST}  references ${d.path} ${DIM}(missing)${RST}`)
-    )
-  );
-  sections.push(
-    section(
-      "broken-links",
-      r.broken_links.length,
-      r.broken_links.map(
-        (b) => `  ${BLUE}${b.source_slug}${RST} \u2192 ${b.target_slug} ${DIM}(target does not exist)${RST}`
-      )
-    )
-  );
-  sections.push(
-    section(
-      "broken-xwiki",
-      r.broken_xwiki.length,
-      r.broken_xwiki.map(
-        (b) => `  ${BLUE}${b.source_slug}${RST} \u2192 ${b.target_wiki}:${b.target_slug} ${DIM}(wiki unregistered or unreachable)${RST}`
-      )
-    )
-  );
-  sections.push(
-    section(
-      "empty-topics",
-      r.empty_topics.length,
-      r.empty_topics.map((e) => `  ${BLUE}${e.slug}${RST}`)
-    )
-  );
-  sections.push(
-    section(
-      "empty-pages",
-      r.empty_pages.length,
-      r.empty_pages.map((e) => `  ${BLUE}${e.slug}${RST}`)
-    )
-  );
-  sections.push(
-    section(
-      "slug-collisions",
-      r.slug_collisions.length,
-      r.slug_collisions.map((c) => `  ${BLUE}${c.slug}${RST}: ${c.paths.join(", ")}`)
-    )
-  );
-  return `${sections.join("\n\n")}
-`;
-}
-function section(label, count, lines) {
-  if (count === 0) return `${BOLD}${label}${RST} ${GREEN}(0): (ok)${RST}`;
-  return `${BOLD}${label}${RST} ${RED}(${count})${RST}:
-${lines.join("\n")}`;
-}
-
 export {
   toKebabCase,
   loadTopicsFile,
@@ -1227,16 +723,6 @@ export {
   looksLikeDir,
   openIndex,
   ensureFreshIndex,
-  runIndexer,
-  readRegistry,
-  addEntry,
-  dropEntry,
-  findEntry,
-  ensureGlobalDir,
-  resolveWikiRoot,
-  ancestorsInFile,
-  descendantsInDb,
-  parseDuration,
-  runHealth
+  runIndexer
 };
-//# sourceMappingURL=chunk-KQUVMF27.js.map
+//# sourceMappingURL=chunk-BFIG2CXM.js.map