project-athena 0.2.1 → 0.4.0

package/dist/chunk-SVTEJYMS.js

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import {
+  athenaDir
+} from "./chunk-2DY4PUR4.js";
+import {
+  readTextIfExists,
+  writeFileAtomic
+} from "./chunk-IQQBAWSM.js";
+import {
+  toPosix
+} from "./chunk-XW3MLHI2.js";
+
+// src/core/graph/graph.ts
+import { z } from "zod";
+import path from "path";
+var NodeKind = z.enum(["package", "file", "route", "entity", "framework", "command", "infra", "doc"]);
+var EdgeKind = z.enum(["contains", "imports", "handles", "defines", "depends_on", "documents", "runs"]);
+var GraphNode = z.object({
+  id: z.string(),
+  kind: NodeKind,
+  name: z.string(),
+  path: z.string().optional(),
+  meta: z.record(z.string(), z.union([z.string(), z.number(), z.boolean()])).default({})
+});
+var GraphEdge = z.object({ from: z.string(), to: z.string(), kind: EdgeKind });
+var ProjectGraph = z.object({
+  schemaVersion: z.literal(1),
+  builtAt: z.string(),
+  nodes: z.array(GraphNode),
+  edges: z.array(GraphEdge),
+  stats: z.object({ nodes: z.number(), edges: z.number(), byKind: z.record(z.string(), z.number()) })
+});
+var GRAPH_FILE = "graph.json";
+var nodeId = (kind, key) => `${kind}:${key}`;
+var IMPORT_RE = /^\s*(?:import\s[^'"]*from\s*['"]([^'"]+)['"]|import\s*['"]([^'"]+)['"]|export\s[^'"]*from\s*['"]([^'"]+)['"]|(?:const|let|var)\s[^=]*=\s*require\(\s*['"]([^'"]+)['"]\s*\))/gm;
+var PY_IMPORT_RE = /^\s*(?:from\s+([.\w]+)\s+import|import\s+([.\w]+))/gm;
+var RESOLVE_EXTS = [".ts", ".tsx", ".js", ".jsx", ".mjs", ".cjs", ".mts", ".py", ".vue", ".svelte"];
+function resolveImport(fromFile, spec, fileSet) {
+  if (!spec.startsWith(".")) return null;
+  const base = toPosix(path.posix.normalize(path.posix.join(path.posix.dirname(fromFile), spec)));
+  if (fileSet.has(base)) return base;
+  for (const ext of RESOLVE_EXTS) {
+    for (const c of [`${base}${ext}`, `${base}/index${ext}`, `${base}/__init__${ext}`]) if (fileSet.has(c)) return c;
+  }
+  return null;
+}
+var compare = new Intl.Collator().compare;
+async function buildGraph(model, opts) {
+  const nodes = /* @__PURE__ */ new Map();
+  const edges = [];
+  const edgeKeys = /* @__PURE__ */ new Set();
+  const fileSet = new Set(opts.files);
+  const addNode = (n) => {
+    if (!nodes.has(n.id)) nodes.set(n.id, n);
+    return n.id;
+  };
+  const addEdge = (from, to, kind) => {
+    if (from === to || !nodes.has(from) || !nodes.has(to)) return;
+    const key = `${from}\0${to}\0${kind}`;
+    if (edgeKeys.has(key)) return;
+    edgeKeys.add(key);
+    edges.push({ from, to, kind });
+  };
+  const fileNode = (p) => addNode({ id: nodeId("file", p), kind: "file", name: path.posix.basename(p), path: p, meta: {} });
+  for (const pkg of model.workspace.packages) {
+    addNode({ id: nodeId("package", pkg.name), kind: "package", name: pkg.name, path: pkg.path, meta: { kind: pkg.kind, ecosystem: pkg.ecosystem } });
+  }
+  for (const pkg of model.workspace.packages) {
+    for (const dep of pkg.internalDependencies) addEdge(nodeId("package", pkg.name), nodeId("package", dep), "depends_on");
+  }
+  const packageAtPath = /* @__PURE__ */ new Map();
+  for (const pkg of model.workspace.packages) if (!packageAtPath.has(pkg.path)) packageAtPath.set(pkg.path, pkg);
+  for (const f of model.frameworks) {
+    const id = addNode({ id: nodeId("framework", `${f.name}@${f.root}`), kind: "framework", name: f.name, path: f.root, meta: { category: f.category, status: f.provenance.status, confidence: f.provenance.confidence } });
+    const owner = packageAtPath.get(f.root);
+    if (owner) addEdge(nodeId("package", owner.name), id, "contains");
+  }
+  for (const r of model.routes) {
+    const id = addNode({ id: nodeId("route", `${r.method} ${r.path} ${r.file}`), kind: "route", name: `${r.method} ${r.path}`, path: r.file, meta: { method: r.method, framework: r.framework, ...r.line ? { line: r.line } : {} } });
+    addEdge(id, fileNode(r.file), "handles");
+  }
+  const entityByName = /* @__PURE__ */ new Map();
+  for (const x of model.dbEntities) {
+    const k = x.name.toLowerCase();
+    if (!entityByName.has(k)) entityByName.set(k, x);
+  }
+  for (const e of model.dbEntities) {
+    const id = addNode({ id: nodeId("entity", `${e.name}@${e.file}`), kind: "entity", name: e.name, path: e.file, meta: { kind: e.kind, fields: e.fields.length, indexes: e.indexes.length } });
+    addEdge(id, fileNode(e.file), "defines");
+    for (const rel of e.relations) {
+      const target = rel.split("\u2192")[1]?.trim();
+      const other = target ? entityByName.get(target.toLowerCase()) : void 0;
+      if (other) addEdge(id, nodeId("entity", `${other.name}@${other.file}`), "depends_on");
+    }
+  }
+  for (const e of model.entryPoints) fileNode(e.path);
+  for (const c of model.commands) {
+    const id = addNode({ id: nodeId("command", `${c.source}:${c.name}`), kind: "command", name: c.name, path: c.source, meta: { purpose: c.purpose, command: c.command.slice(0, 120) } });
+    addEdge(id, fileNode(c.source), "runs");
+  }
+  for (const i of model.infrastructure) addNode({ id: nodeId("infra", `${i.name}@${i.file}`), kind: "infra", name: i.name, path: i.file, meta: { kind: i.kind } });
+  for (const d of model.containers.dockerfiles) addNode({ id: nodeId("infra", `Dockerfile@${d.path}`), kind: "infra", name: "Dockerfile", path: d.path, meta: { kind: "container" } });
+  for (const s of model.containers.services) addNode({ id: nodeId("infra", `service:${s.name}@${s.file}`), kind: "infra", name: s.name, path: s.file, meta: { kind: "service", image: s.image ?? "" } });
+  for (const n of [...nodes.values()].filter((x) => x.kind === "file" && x.path)) {
+    const p = n.path;
+    let owner;
+    for (let i = p.lastIndexOf("/"); i >= 0 && !owner; i = i > 0 ? p.lastIndexOf("/", i - 1) : -1) {
+      const prefix = p.slice(0, i);
+      if (prefix !== ".") owner = packageAtPath.get(prefix);
+    }
+    if (owner) addEdge(nodeId("package", owner.name), n.id, "contains");
+  }
+  const maxImportFiles = opts.maxImportFiles ?? 2e3;
+  const queue = [...nodes.values()].filter((n) => n.kind === "file").map((n) => n.path);
+  const parsed = /* @__PURE__ */ new Set();
+  let head = 0;
+  while (head < queue.length && parsed.size < maxImportFiles) {
+    opts.signal?.throwIfAborted();
+    const p = queue[head++];
+    if (parsed.has(p)) continue;
+    parsed.add(p);
+    const n = { id: nodeId("file", p) };
+    if (!/\.(m|c)?(t|j)sx?$|\.py$/.test(p)) continue;
+    const text = await opts.read(p);
+    if (!text) continue;
+    const specs = [];
+    for (const m of text.matchAll(IMPORT_RE)) specs.push(m[1] ?? m[2] ?? m[3] ?? m[4]);
+    if (p.endsWith(".py")) for (const m of text.matchAll(PY_IMPORT_RE)) specs.push((m[1] ?? m[2]).replace(/\./g, "/"));
+    for (const spec of specs.slice(0, 200)) {
+      const target = resolveImport(p, spec, fileSet);
+      if (!target) continue;
+      addEdge(n.id, fileNode(target), "imports");
+      if (!parsed.has(target)) queue.push(target);
+    }
+  }
+  const byKind = {};
+  for (const n of nodes.values()) byKind[n.kind] = (byKind[n.kind] ?? 0) + 1;
+  return {
+    schemaVersion: 1,
+    builtAt: (/* @__PURE__ */ new Date()).toISOString(),
+    nodes: [...nodes.values()].sort((a, b) => compare(a.id, b.id)),
+    edges: edges.sort((a, b) => compare(a.from, b.from) || compare(a.to, b.to)),
+    stats: { nodes: nodes.size, edges: edges.length, byKind }
+  };
+}
+async function saveGraph(root, graph) {
+  await writeFileAtomic(path.join(athenaDir(root), GRAPH_FILE), `${JSON.stringify(graph, null, 2)}
+`);
+}
+async function loadGraph(root) {
+  const raw = await readTextIfExists(path.join(athenaDir(root), GRAPH_FILE));
+  if (!raw) return null;
+  try {
+    const parsed = ProjectGraph.safeParse(JSON.parse(raw));
+    return parsed.success ? parsed.data : null;
+  } catch {
+    return null;
+  }
+}
+var indexes = /* @__PURE__ */ new WeakMap();
+function graphIndex(graph) {
+  let idx = indexes.get(graph);
+  if (idx && idx.nodeCount === graph.nodes.length && idx.edgeCount === graph.edges.length) return idx;
+  const byId = /* @__PURE__ */ new Map();
+  for (const n of graph.nodes) byId.set(n.id, n);
+  const incident = /* @__PURE__ */ new Map();
+  const add = (id, i) => {
+    const list = incident.get(id);
+    if (!list) incident.set(id, [i]);
+    else if (list[list.length - 1] !== i) list.push(i);
+  };
+  graph.edges.forEach((e, i) => {
+    add(e.from, i);
+    add(e.to, i);
+  });
+  idx = { byId, incident, nodeCount: graph.nodes.length, edgeCount: graph.edges.length };
+  indexes.set(graph, idx);
+  return idx;
+}
+function neighbors(graph, id) {
+  const node = graph.nodes.find((n) => n.id === id);
+  if (!node) return null;
+  const { byId, incident } = graphIndex(graph);
+  const out = [];
+  for (const i of incident.get(id) ?? []) {
+    const e = graph.edges[i];
+    if (e.from === id && byId.has(e.to)) out.push({ edge: e, other: byId.get(e.to), direction: "out" });
+    else if (e.to === id && byId.has(e.from)) out.push({ edge: e, other: byId.get(e.from), direction: "in" });
+  }
+  return { node, edges: out };
+}
+function expandFromFiles(graph, files, depth = 1, limit = 40) {
+  const { byId, incident } = graphIndex(graph);
+  const fileSet = new Set(files);
+  const seed = graph.nodes.filter((n) => n.path && fileSet.has(n.path));
+  const seen = new Set(seed.map((n) => n.id));
+  let frontier = new Set(seen);
+  for (let d = 0; d < depth; d++) {
+    const touched = /* @__PURE__ */ new Set();
+    for (const id of frontier) for (const i of incident.get(id) ?? []) touched.add(i);
+    const next = /* @__PURE__ */ new Set();
+    for (const i of [...touched].sort((a, b) => a - b)) {
+      const e = graph.edges[i];
+      if (frontier.has(e.from) && !seen.has(e.to)) {
+        seen.add(e.to);
+        next.add(e.to);
+      } else if (frontier.has(e.to) && !seen.has(e.from)) {
+        seen.add(e.from);
+        next.add(e.from);
+      }
+    }
+    frontier = next;
+    if (!frontier.size) break;
+  }
+  return [...seen].map((id) => byId.get(id)).filter((n) => Boolean(n)).slice(0, limit);
+}
+
+export {
+  ProjectGraph,
+  GRAPH_FILE,
+  buildGraph,
+  saveGraph,
+  loadGraph,
+  neighbors,
+  expandFromFiles
+};
+//# sourceMappingURL=chunk-SVTEJYMS.js.map