@iowarp/clio-coder 0.4.6 → 0.4.8

package/dist/context-map-DKL3QT6D.js

@@ -0,0 +1,555 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  WIKI_DEPTH_STRATEGY,
+  areaForPath,
+  classifyDepth
+} from "./chunk-PECBKCDK.js";
+import {
+  coordinateCodewikiWrite
+} from "./chunk-WWRV5RJI.js";
+import {
+  CLIO_ARTIFACT_DIR
+} from "./chunk-NTTS3O53.js";
+import "./chunk-DVJL77SO.js";
+import "./chunk-TK2BMCBZ.js";
+import "./chunk-W2RJEH6Q.js";
+import "./chunk-ZZFWWYLX.js";
+import {
+  init_esm_shims
+} from "./chunk-ECBHH7LU.js";
+
+// src/cli/context-map.ts
+init_esm_shims();
+import { execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path from "node:path";
+
+// src/domains/context/wiki/map-seed.ts
+init_esm_shims();
+var MAX_SEED_COMPONENTS = 12;
+var MAX_SEED_EXTERNALS = 3;
+var MAX_SEED_CONNECTIONS = 16;
+var MAX_SEED_SOURCES = 3;
+var GRID_COLS = 4;
+var CELL_W = 220;
+var CELL_H = 72;
+var GAP_X = 70;
+var LANE_STEP = 16;
+var LANE_MARGIN = 24;
+var LABEL_BESIDE_OFFSET = 48;
+var GITHUB_REPOSITORY_URL = /^https:\/\/github\.com\/[A-Za-z0-9_.-]+\/[A-Za-z0-9_.-]+(?:\.git)?\/?$/;
+var FULL_REVISION = /^[a-fA-F0-9]{40}$/;
+var DATABASE_DIR = /^(?:store|stores|storage|persistence|persist|db|database|databases|repository|repositories|dao)$/i;
+function areaId(key) {
+  const slug = key.replace(/[^A-Za-z0-9]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+  const body = slug.length > 0 ? slug : "root";
+  return /^[a-z]/.test(body) ? body : `a-${body}`;
+}
+function uniqueIds(preferred) {
+  const reserved = new Set(preferred);
+  const used = /* @__PURE__ */ new Set();
+  return preferred.map((base) => {
+    let id = base;
+    if (used.has(id)) {
+      let suffix = 2;
+      do {
+        id = `${base}-${suffix++}`;
+      } while (reserved.has(id) || used.has(id));
+    }
+    used.add(id);
+    return id;
+  });
+}
+function componentTypeFor(area) {
+  const last = area.key.split("/").filter(Boolean).at(-1) ?? "";
+  if (DATABASE_DIR.test(last)) return "database";
+  if (area.files.some((file) => file.role === "entry")) return "frontend";
+  return "backend";
+}
+function collectAreas(files, areaDepth) {
+  const byKey = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const key = areaForPath(file.path, areaDepth);
+    const area = byKey.get(key) ?? { key, files: [], loc: 0 };
+    area.files.push(file);
+    area.loc += Math.max(0, file.loc);
+    byKey.set(key, area);
+  }
+  return [...byKey.values()].sort(
+    (a, b) => b.files.length - a.files.length || b.loc - a.loc || a.key.localeCompare(b.key)
+  );
+}
+function firstSymbolLines(symbols) {
+  const lines = /* @__PURE__ */ new Map();
+  for (const symbol of symbols) {
+    if (!Number.isInteger(symbol.line) || symbol.line < 1) continue;
+    const current = lines.get(symbol.fileId);
+    if (current === void 0 || symbol.line < current) lines.set(symbol.fileId, symbol.line);
+  }
+  return lines;
+}
+function sourcesFor(area, lines) {
+  return [...area.files].sort((a, b) => b.loc - a.loc || a.path.localeCompare(b.path)).slice(0, MAX_SEED_SOURCES).map((file) => {
+    const line = lines.get(file.id);
+    return line === void 0 ? { path: file.path } : { line, path: file.path };
+  });
+}
+function isInternalEdge(edge) {
+  return "toFileId" in edge;
+}
+function externalPackage(specifier) {
+  if (specifier.startsWith("node:") || NODE_BUILTINS.has(specifier)) return null;
+  const segments = specifier.split("/");
+  if (specifier.startsWith("@")) return segments.length >= 2 ? `${segments[0]}/${segments[1]}` : null;
+  return segments[0] && segments[0].length > 0 ? segments[0] : null;
+}
+var NODE_BUILTINS = /* @__PURE__ */ new Set([
+  "assert",
+  "buffer",
+  "child_process",
+  "crypto",
+  "events",
+  "fs",
+  "http",
+  "https",
+  "module",
+  "net",
+  "os",
+  "path",
+  "process",
+  "readline",
+  "stream",
+  "url",
+  "util",
+  "zlib"
+]);
+function serializeArchitectureSeed(seed) {
+  const sortKeys = (value) => {
+    if (Array.isArray(value)) return value.map(sortKeys);
+    if (value && typeof value === "object") {
+      return Object.fromEntries(
+        Object.keys(value).sort().map((key) => [key, sortKeys(value[key])])
+      );
+    }
+    return value;
+  };
+  return `${JSON.stringify(sortKeys(seed), null, 2)}
+`;
+}
+function assignRows(nodes, edges) {
+  const ids = nodes.filter((node) => node.type !== "external").map((node) => node.id);
+  const successors = new Map(ids.map((id) => [id, /* @__PURE__ */ new Set()]));
+  const reaches = (from, to) => {
+    const stack = [from];
+    const seen = /* @__PURE__ */ new Set();
+    while (stack.length > 0) {
+      const current = stack.pop();
+      if (current === to) return true;
+      if (seen.has(current)) continue;
+      seen.add(current);
+      for (const next of successors.get(current) ?? []) stack.push(next);
+    }
+    return false;
+  };
+  for (const edge of edges) {
+    if (!successors.has(edge.from) || !successors.has(edge.to)) continue;
+    if (reaches(edge.to, edge.from)) continue;
+    successors.get(edge.from)?.add(edge.to);
+  }
+  const layer = /* @__PURE__ */ new Map();
+  const depth = (id) => {
+    const known = layer.get(id);
+    if (known !== void 0) return known;
+    let best = 0;
+    for (const node of ids) {
+      if (successors.get(node)?.has(id)) best = Math.max(best, depth(node) + 1);
+    }
+    layer.set(id, best);
+    return best;
+  };
+  for (const id of ids) depth(id);
+  const rows = /* @__PURE__ */ new Map();
+  let row = 0;
+  const layers = [...new Set(ids.map((id) => layer.get(id)))].sort((a, b) => a - b);
+  for (const current of layers) {
+    const members = ids.filter((id) => layer.get(id) === current);
+    members.forEach((id, index) => {
+      rows.set(id, row + Math.floor(index / GRID_COLS));
+    });
+    row += Math.ceil(members.length / GRID_COLS);
+  }
+  const externals = nodes.filter((node) => node.type === "external");
+  externals.forEach((node, index) => {
+    rows.set(node.id, row + Math.floor(index / GRID_COLS));
+  });
+  return rows;
+}
+function placeAndRoute(nodes, edges) {
+  const rowOf = assignRows(nodes, edges);
+  const colOf = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Map();
+  for (const node of nodes) {
+    const row = rowOf.get(node.id);
+    const col = used.get(row) ?? 0;
+    colOf.set(node.id, col);
+    used.set(row, col + 1);
+  }
+  const gapLanes = /* @__PURE__ */ new Map();
+  const leftLanes = { count: 0 };
+  const rightLanes = { count: 0 };
+  const takeGap = (row) => {
+    const lane = gapLanes.get(row) ?? 0;
+    gapLanes.set(row, lane + 1);
+    return lane;
+  };
+  const plans = edges.map((edge) => {
+    const fromRow = rowOf.get(edge.from);
+    const toRow = rowOf.get(edge.to);
+    const sameCol = colOf.get(edge.from) === colOf.get(edge.to);
+    if (fromRow === toRow) {
+      return { edge, fromSide: "bottom", toSide: "bottom", straight: false, gaps: [[fromRow, takeGap(fromRow)]] };
+    }
+    if (fromRow < toRow) {
+      if (toRow === fromRow + 1) {
+        return {
+          edge,
+          fromSide: "bottom",
+          toSide: "top",
+          straight: sameCol,
+          gaps: sameCol ? [] : [[fromRow, takeGap(fromRow)]]
+        };
+      }
+      return {
+        edge,
+        fromSide: "bottom",
+        toSide: "top",
+        straight: false,
+        gaps: [
+          [fromRow, takeGap(fromRow)],
+          [toRow - 1, takeGap(toRow - 1)]
+        ],
+        margin: { side: "left", lane: leftLanes.count++ }
+      };
+    }
+    if (fromRow === toRow + 1) {
+      return {
+        edge,
+        fromSide: "top",
+        toSide: "bottom",
+        straight: sameCol,
+        gaps: sameCol ? [] : [[toRow, takeGap(toRow)]]
+      };
+    }
+    return {
+      edge,
+      fromSide: "top",
+      toSide: "bottom",
+      straight: false,
+      gaps: [
+        [fromRow - 1, takeGap(fromRow - 1)],
+        [toRow, takeGap(toRow)]
+      ],
+      margin: { side: "right", lane: rightLanes.count++ }
+    };
+  });
+  const maxGapLanes = Math.max(0, ...gapLanes.values());
+  const gapY = Math.max(90, 2 * LANE_MARGIN + Math.max(1, maxGapLanes) * LANE_STEP);
+  const originX = LANE_MARGIN + Math.max(1, leftLanes.count) * LANE_STEP + LANE_MARGIN;
+  const layout = {
+    mode: "grid",
+    origin: [originX, 80],
+    cols: GRID_COLS,
+    cellW: CELL_W,
+    cellH: CELL_H,
+    gapX: GAP_X,
+    gapY
+  };
+  const centerX = (id) => originX + colOf.get(id) * (CELL_W + GAP_X) + CELL_W / 2;
+  const topY = (row) => layout.origin[1] + row * (CELL_H + gapY);
+  const laneY = (row, lane) => topY(row) + CELL_H + LANE_MARGIN + lane * LANE_STEP;
+  const gridRight = originX + GRID_COLS * (CELL_W + GAP_X) - GAP_X;
+  const marginX = (margin) => margin.side === "left" ? originX - LANE_MARGIN - margin.lane * LANE_STEP : gridRight + LANE_MARGIN + margin.lane * LANE_STEP;
+  const components = nodes.map((node) => ({
+    id: node.id,
+    type: node.type,
+    label: node.label,
+    sublabel: node.sublabel,
+    row: rowOf.get(node.id),
+    col: colOf.get(node.id),
+    size: [CELL_W, CELL_H],
+    ...node.sources ? { sources: node.sources } : {}
+  }));
+  const connectionIds = uniqueIds(plans.map(({ edge }) => `${edge.from}-to-${edge.to}`));
+  const connections = plans.map((plan, index) => {
+    const { edge } = plan;
+    const base = {
+      id: connectionIds[index],
+      from: edge.from,
+      to: edge.to,
+      label: `${edge.weight} import${edge.weight === 1 ? "" : "s"}`,
+      fromSide: plan.fromSide,
+      toSide: plan.toSide
+    };
+    const xa = centerX(edge.from);
+    const xb = centerX(edge.to);
+    if (plan.straight) {
+      const upperRow = Math.min(rowOf.get(edge.from), rowOf.get(edge.to));
+      const gapMid = topY(upperRow) + CELL_H + gapY / 2;
+      return { ...base, route: "straight", labelAt: [xa + LABEL_BESIDE_OFFSET, gapMid] };
+    }
+    const [first, second] = plan.gaps;
+    if (!first) return { ...base, route: "straight" };
+    const y1 = laneY(first[0], first[1]);
+    if (!plan.margin || !second)
+      return {
+        ...base,
+        via: [
+          [xa, y1],
+          [xb, y1]
+        ]
+      };
+    const y2 = laneY(second[0], second[1]);
+    const mx = marginX(plan.margin);
+    return {
+      ...base,
+      via: [
+        [xa, y1],
+        [mx, y1],
+        [mx, y2],
+        [xb, y2]
+      ]
+    };
+  });
+  return { layout, components, connections };
+}
+function buildArchitectureSeed(codewiki, options) {
+  const source = codewiki.files.filter((file) => file.lang !== "config");
+  const sourceLines = source.reduce((total, file) => total + Math.max(0, file.loc), 0);
+  const { areaDepth } = WIKI_DEPTH_STRATEGY[classifyDepth(source.length, sourceLines)];
+  const areas = collectAreas(source, areaDepth).slice(0, MAX_SEED_COMPONENTS);
+  const lines = firstSymbolLines(codewiki.symbols);
+  const areaByFile = /* @__PURE__ */ new Map();
+  for (const area of areas) for (const file of area.files) areaByFile.set(file.id, area.key);
+  const repository = options.repository;
+  const pinned = repository && GITHUB_REPOSITORY_URL.test(repository.url) && FULL_REVISION.test(repository.revision) ? { url: repository.url, revision: repository.revision.toLowerCase() } : void 0;
+  const externalCounts = /* @__PURE__ */ new Map();
+  const externalWeights = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    if (isInternalEdge(edge)) continue;
+    const fromArea = areaByFile.get(edge.fileId);
+    const pkg = externalPackage(edge.externalModule);
+    if (fromArea === void 0 || pkg === null) continue;
+    externalCounts.set(pkg, (externalCounts.get(pkg) ?? 0) + 1);
+    const key = `${fromArea}\0${pkg}`;
+    externalWeights.set(key, (externalWeights.get(key) ?? 0) + 1);
+  }
+  const externals = [...externalCounts.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_SEED_EXTERNALS).map(([module]) => module);
+  const componentIds = uniqueIds([
+    ...areas.map((area) => areaId(area.key)),
+    ...externals.map((module) => `ext-${areaId(module)}`)
+  ]);
+  const idByArea = new Map(areas.map((area, index) => [area.key, componentIds[index]]));
+  const idByExternal = new Map(externals.map((module, index) => [module, componentIds[areas.length + index]]));
+  const nodes = areas.map((area) => {
+    const sources = pinned ? sourcesFor(area, lines) : [];
+    return {
+      id: idByArea.get(area.key),
+      type: componentTypeFor(area),
+      label: area.key,
+      sublabel: `${area.files.length} file${area.files.length === 1 ? "" : "s"}, ${area.loc} LOC`,
+      ...sources.length > 0 ? { sources } : {}
+    };
+  });
+  for (const module of externals) {
+    const count = externalCounts.get(module) ?? 0;
+    nodes.push({
+      id: idByExternal.get(module),
+      type: "external",
+      label: module,
+      sublabel: `${count} import${count === 1 ? "" : "s"}`
+    });
+  }
+  const weights = /* @__PURE__ */ new Map();
+  for (const edge of codewiki.edges) {
+    if (!isInternalEdge(edge)) continue;
+    const from = areaByFile.get(edge.fileId);
+    const to = areaByFile.get(edge.toFileId);
+    if (from === void 0 || to === void 0 || from === to) continue;
+    const key = `${from}\0${to}\0internal`;
+    weights.set(key, (weights.get(key) ?? 0) + 1);
+  }
+  for (const module of externals) {
+    for (const area of areas) {
+      const weight = externalWeights.get(`${area.key}\0${module}`);
+      if (weight) weights.set(`${area.key}\0${module}\0external`, weight);
+    }
+  }
+  const edges = [...weights.entries()].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, MAX_SEED_CONNECTIONS).map(([key, weight]) => {
+    const [fromKey, toKey, kind] = key.split("\0");
+    const from = idByArea.get(fromKey);
+    const to = (kind === "internal" ? idByArea : idByExternal).get(toKey);
+    return { from, to, weight };
+  });
+  const { layout, components, connections } = placeAndRoute(nodes, edges);
+  const meta = {
+    title: options.title,
+    quality_profile: "standard",
+    ...pinned ? { repository: pinned } : {}
+  };
+  return {
+    schema_version: 1,
+    diagram_type: "architecture",
+    meta,
+    layout,
+    components,
+    connections
+  };
+}
+
+// src/cli/context-map.ts
+var HELP = `Usage:
+  clio-coder context map [--out <path>] [--json]
+
+Write an archify architecture seed for the current repository from the codewiki
+index, without model calls. The seed is the starting spec for the archify skill:
+components are the largest directory areas, connections are collapsed import
+edges. The index is reconciled with current files before mapping; sources are
+pinned only when clean Git evidence matches those files.
+
+Options:
+  --out <path>    where to write the seed (default: ${CLIO_ARTIFACT_DIR}/maps/<repo>.architecture.json)
+  --json          print machine-readable details about the written seed
+`;
+function defaultMapSeedPath(cwd) {
+  return path.join(cwd, CLIO_ARTIFACT_DIR, "maps", `${path.basename(cwd)}.architecture.json`);
+}
+function gitValue(cwd, args) {
+  try {
+    const out = execFileSync("git", args, { cwd, timeout: 5e3, stdio: ["ignore", "pipe", "ignore"] }).toString("utf8").trim();
+    return out;
+  } catch {
+    return null;
+  }
+}
+function repositoryFacts(cwd, codewiki, indexedHead) {
+  const revision = gitValue(cwd, ["rev-parse", "--verify", "HEAD"]);
+  const status = gitValue(cwd, ["status", "--porcelain", "--untracked-files=normal"]);
+  if (!revision || status === null) return { sourceState: "unknown" };
+  if (status !== "" || revision !== indexedHead) return { sourceState: "dirty" };
+  if (gitValue(cwd, ["rev-parse", "--show-prefix"]) !== "") return { sourceState: "unknown" };
+  const tree = gitValue(cwd, ["ls-tree", "-r", "-z", revision]);
+  if (tree === null) return { sourceState: "unknown" };
+  const blobs = /* @__PURE__ */ new Map();
+  for (const entry of tree.split("\0")) {
+    const match = /^100[0-7]{3} blob ([a-f0-9]{40})\t([\s\S]+)$/.exec(entry);
+    if (match) blobs.set(match[2], match[1]);
+  }
+  try {
+    for (const file of codewiki.files) {
+      const contents = readFileSync(path.join(cwd, file.path));
+      const indexedHash = createHash("sha256").update(contents.toString("utf8")).digest("hex").slice(0, 16);
+      const blob = createHash("sha1").update(`blob ${contents.length}\0`).update(contents).digest("hex");
+      if (indexedHash !== file.hash || blobs.get(file.path) !== blob) return { sourceState: "dirty" };
+    }
+  } catch {
+    return { sourceState: "unknown" };
+  }
+  const remote = gitValue(cwd, ["remote", "get-url", "origin"]);
+  if (!remote) return { sourceState: "clean" };
+  let url = remote.endsWith(".git") ? remote.slice(0, -4) : remote;
+  const ssh = /^git@([^:]+):(.+)$/.exec(url);
+  if (ssh) url = `https://${ssh[1]}/${ssh[2]}`;
+  return { sourceState: "clean", repository: { url, revision } };
+}
+async function runContextMapCommand(args) {
+  if (args.includes("--help") || args.includes("-h")) {
+    process.stdout.write(HELP);
+    return 0;
+  }
+  let out = null;
+  let json = false;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--json") {
+      json = true;
+      continue;
+    }
+    if (arg === "--out") {
+      const value = args[index + 1];
+      if (!value || value.startsWith("--")) {
+        process.stderr.write("clio-coder context map: --out requires a path\n");
+        return 2;
+      }
+      out = value;
+      index += 1;
+      continue;
+    }
+    process.stderr.write(`clio-coder context map: unknown flag ${arg}
+`);
+    return 2;
+  }
+  const cwd = process.cwd();
+  let reconciled;
+  try {
+    reconciled = await coordinateCodewikiWrite(
+      cwd,
+      (current, workspace) => current ? {
+        kind: "ensure",
+        cwd: workspace,
+        current,
+        language: current.language,
+        // Map evidence must reconcile actual inputs, even if a state file
+        // happens to carry a matching fingerprint from another operation.
+        previous: null
+      } : null,
+      { requireExisting: true }
+    );
+  } catch (error) {
+    process.stderr.write(
+      `clio-coder context map: index refresh failed: ${error instanceof Error ? error.message : String(error)}
+`
+    );
+    return 1;
+  }
+  if (!reconciled) {
+    process.stderr.write(
+      "clio-coder context map: no codewiki index in .clio-coder/codewiki.json; run `clio-coder context index` first\n"
+    );
+    return 1;
+  }
+  const facts = repositoryFacts(cwd, reconciled.codewiki, reconciled.worker.fingerprint.gitHead);
+  const seed = buildArchitectureSeed(reconciled.codewiki, {
+    title: path.basename(cwd),
+    repository: facts.repository
+  });
+  const target = out ? path.resolve(cwd, out) : defaultMapSeedPath(cwd);
+  mkdirSync(path.dirname(target), { recursive: true });
+  writeFileSync(target, serializeArchitectureSeed(seed), "utf8");
+  const payload = {
+    path: target,
+    components: seed.components.length,
+    connections: seed.connections.length,
+    repository: seed.meta.repository ?? null,
+    index: "reconciled",
+    sourceState: facts.sourceState
+  };
+  if (json) {
+    process.stdout.write(`${JSON.stringify(payload, null, 2)}
+`);
+    return 0;
+  }
+  process.stdout.write(
+    [
+      `clio-coder context map wrote ${target}`,
+      `  ${payload.components} components, ${payload.connections} connections${payload.repository ? `, sources pinned at ${payload.repository.revision.slice(0, 12)}` : `; no source citations (source state: ${payload.sourceState}; requires verified clean files and a GitHub origin at a full revision)`}`,
+      payload.repository ? "  next: validate and deliver it with the archify skill, passing --repo-root ." : "  next: validate and deliver it with the archify skill (without --repo-root)",
+      ""
+    ].join("\n")
+  );
+  return 0;
+}
+export {
+  runContextMapCommand
+};
+//# sourceMappingURL=context-map-DKL3QT6D.js.map