@fraczak/k 6.0.1 → 6.0.2

package/scripts/generate-dependency-graph.mjs

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { execSync } from "node:child_process";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const root = path.resolve(__dirname, "..");
+const outPath = path.join(root, "DOCS", "dependency-graph.md");
+
+function getTrackedMjsFiles() {
+  const raw = execSync("git ls-files '*.mjs'", {
+    cwd: root,
+    encoding: "utf8"
+  });
+
+  const all = raw
+    .split("\n")
+    .map((s) => s.trim())
+    .filter(Boolean);
+
+  return all.filter((relPath) => {
+    if (relPath.startsWith("codecs/")) return true;
+    if (relPath.includes("/")) return false;
+    if (relPath.startsWith("test")) return false;
+    if (relPath.includes("-test")) return false;
+    return true;
+  });
+}
+
+function parseLocalImports(absPath) {
+  const source = fs.readFileSync(absPath, "utf8");
+  const regex = /^\s*import\s+[^;]*?from\s+["']([^"']+)["'];?\s*$/gm;
+  const imports = [];
+  let match;
+  while ((match = regex.exec(source)) !== null) {
+    const specifier = match[1];
+    if (specifier.startsWith("./") || specifier.startsWith("../")) {
+      imports.push(specifier);
+    }
+  }
+  return imports;
+}
+
+function toNodeId(relPath) {
+  return relPath.replace(/[^a-zA-Z0-9]/g, "_");
+}
+
+function makeBar(sizeKb) {
+  const units = Math.max(1, Math.min(20, Math.round(sizeKb)));
+  return "█".repeat(units);
+}
+
+function renderGraph(files, sizesKb, edges) {
+  const lines = [];
+  lines.push("# Project Dependency Graph");
+  lines.push("");
+  lines.push("_Auto-generated by scripts/generate-dependency-graph.mjs._");
+  lines.push("");
+  lines.push("```mermaid");
+  lines.push("graph TD");
+  lines.push("    classDef default fill:#fff,stroke:#333,stroke-width:2px,color:#000;");
+  lines.push("");
+
+  for (const relPath of files) {
+    const id = toNodeId(relPath);
+    const sizeKb = sizesKb[relPath];
+    const bar = makeBar(sizeKb);
+    lines.push(`    ${id}[\"${relPath} (${sizeKb.toFixed(1)} KB)<br/>${bar}\"]`);
+  }
+
+  if (edges.length > 0) {
+    lines.push("");
+  }
+
+  for (const { src, dst } of edges) {
+    lines.push(`    ${toNodeId(src)} --> ${toNodeId(dst)}`);
+  }
+
+  lines.push("```");
+  lines.push("");
+  return lines.join("\n");
+}
+
+function main() {
+  const files = getTrackedMjsFiles().sort();
+  const fileSet = new Set(files);
+
+  const sizesKb = {};
+  for (const relPath of files) {
+    const absPath = path.join(root, relPath);
+    const bytes = fs.statSync(absPath).size;
+    sizesKb[relPath] = bytes / 1024;
+  }
+
+  const edgeKeys = new Set();
+  const edges = [];
+  for (const relPath of files) {
+    const absPath = path.join(root, relPath);
+    const imports = parseLocalImports(absPath);
+
+    for (const specifier of imports) {
+      const resolved = path.normalize(path.join(path.dirname(relPath), specifier));
+      if (!resolved.endsWith(".mjs")) continue;
+      if (!fileSet.has(resolved)) continue;
+      const key = `${relPath}->${resolved}`;
+      if (edgeKeys.has(key)) continue;
+      edgeKeys.add(key);
+      edges.push({ src: relPath, dst: resolved });
+    }
+  }
+
+  const graph = renderGraph(files, sizesKb, edges);
+  fs.writeFileSync(outPath, graph, "utf8");
+  console.log(`Wrote ${path.relative(root, outPath)}`);
+  console.log(`Nodes: ${files.length}, Edges: ${edges.length}`);
+}
+
+main();

package/test-repl2.mjs

@@ -4,7 +4,18 @@ import os from "node:os";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-import { completeInput, createState, evaluateInput, isMainEntrypoint } from "./repl2.mjs";
+import {
+  aliasNames,
+  analyzeAcceptedSnippet,
+  analyzeRawSnippet,
+  completeInput,
+  createState,
+  evaluateInput,
+  explicitSnippetTerminated,
+  isMainEntrypoint,
+  lineHasExplicitContinuation,
+  lineTerminatesSnippet
+} from "./repl2.mjs";
 import { decodeObject, objectToFunction } from "./object.mjs";
 import { Product } from "./Value.mjs";
 
@@ -41,12 +52,38 @@ assert(completions.some((line) => line.endsWith(state.typeAliases.nat)));
 completions = completeInput(`(${canonicalPartial}`, state)[0];
 assert(completions.includes(`(${state.typeAliases.nat}`));
 
+completions = completeInput(":run su", state)[0];
+assert(completions.includes(":run succ"));
+
+completions = completeInput("$na", state)[0];
+assert(completions.includes("$nat"));
+
+assert.deepEqual(aliasNames(state), ["nat", "succ"]);
+assert.equal(lineTerminatesSnippet(";"), true);
+assert.equal(lineTerminatesSnippet("  ;   "), true);
+assert.equal(lineTerminatesSnippet("  ;   -- comment"), false);
+assert.equal(lineTerminatesSnippet("succ"), false);
+assert.equal(explicitSnippetTerminated("$ bool = <{} true, {} false>;"), true);
+assert.equal(lineHasExplicitContinuation("succ \\"), true);
+assert.equal(analyzeRawSnippet("$ bool = <{} true, {} false>").kind, "incomplete");
+assert.equal(analyzeAcceptedSnippet("$ bool = <{} true, {} false>;", true).kind, "definitionsOnly");
+assert.equal(analyzeRawSnippet("a =").kind, "incomplete");
+assert.equal(analyzeRawSnippet("{} | succ").kind, "withMain");
+
+const offsetState = createState();
+await evaluateInput(":type ab = <{} 1, {} 2>", offsetState);
+await evaluateInput(":type bool = <{} true, {} false>", offsetState);
+await assert.rejects(
+  () => evaluateInput("$ab", offsetState),
+  /Type Error in 'filter' \(lines 1:1\.\.\.1:4\)/
+);
+
 const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "k-repl2-"));
 const libPath = path.join(tmpDir, "session.klib");
 const koPath = path.join(tmpDir, "succ.ko");
 const sourcePath = path.join(tmpDir, "session.k");
 const symlinkPath = path.resolve(".test-k-repl2-link");
-output = await evaluateInput(`:save ${libPath}`, state);
+output = await evaluateInput(`:klib ${libPath}`, state);
 assert.equal(output[0], `saved ${libPath}`);
 
 completions = completeInput(`:load ${tmpDir}/ses`, state)[0];
@@ -89,12 +126,22 @@ output = await evaluateInput("succ", reloaded);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
 const shorthand = createState();
-output = await evaluateInput("$ nat = <{} zero, nat succ>;", shorthand);
-assert.match(output[0], /^\$ nat = @/);
-output = await evaluateInput("succ = |succ;", shorthand);
-assert.match(output[0], /^succ = @/);
-output = await evaluateInput("succ", shorthand);
-assert.equal(output[0], "{}|succ ?<{} succ, ...>");
+output = await evaluateInput("$ nat = <{} zero, nat succ>\n; succ = |succ\n;", shorthand);
+assert.deepEqual(output, []);
+output = await evaluateInput(":codes", shorthand);
+assert.match(output[0], /^nat = @/m);
+output = await evaluateInput(":rels", shorthand);
+assert.match(output[0], /^succ = @/m);
+output = await evaluateInput("$ bool = <{} true, {} false>\n; not = $bool </true | false, {} | true >\n; {} | true not", shorthand);
+assert.match(output[0], /^\{\}\|false \?</);
+assert.match(output[0], / false/);
+assert.match(output[0], / true/);
+output = await evaluateInput("$ maybe = <{} none, {} some>;", shorthand);
+assert.deepEqual(output, []);
+output = await evaluateInput(":codes", shorthand);
+assert.match(output[0], /^maybe = @/m);
+output = await evaluateInput("{} | true not", shorthand);
+assert.match(output[0], /^\{\}\|false \?</);
 
 await assert.rejects(
   () => evaluateInput("/type", createState()),