@fraczak/k 6.0.1 → 6.0.3

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-k-object.mjs

@@ -6,7 +6,14 @@ import { decodeWire, encodeToWire, CORE_PATTERN_PROPERTY_LIST } from "./codecs/r
 import { Product, Variant } from "./Value.mjs";
 import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
-import { compileObjectBuffer, decodeObject, objectToFunction, decompileObjectBuffer } from "./object.mjs";
+import {
+  compileObjectBuffer,
+  compileLibraryBuffer,
+  decodeObject,
+  objectToFunction,
+  decompileObjectBuffer,
+  extractAliasesFromObject
+} from "./object.mjs";
 
 const value = parseValue("{a:{b:x,c:{}}}");
 const wire = encodeToWire(value, null);
@@ -71,4 +78,73 @@ const sccSource = decompileObjectBuffer(compileObjectBuffer("c = {}; b = c |x; a
 assert.match(sccSource, /----- rels -----\nPQgV = .+\n\naQAD = .+\n\nN9UH = /s);
 assert.deepEqual(k.compile(sccSource)(new Product({})).toJSON(), { y: "x" });
 
+const library = decodeObject(compileLibraryBuffer("$ nat = <{} zero, nat succ>;\nsucc = |succ;\n", { source: "defs-only.k" }));
+assert.equal(library.main, null);
+assert(Object.values(library.meta).some(({ type, origins }) =>
+  type === "code" &&
+  origins.some((origin) =>
+    origin.source === "defs-only.k" &&
+    origin.name === "nat" &&
+    JSON.stringify(Object.keys(origin).sort()) === JSON.stringify(["compiledAt", "name", "source"]) &&
+    typeof origin.compiledAt === "string"
+  )
+));
+assert(Object.values(library.meta).some(({ type, origins }) =>
+  type === "rel" &&
+  origins.some((origin) =>
+    origin.source === "defs-only.k" &&
+    origin.name === "succ" &&
+    JSON.stringify(Object.keys(origin).sort()) === JSON.stringify(["compiledAt", "name", "source"]) &&
+    typeof origin.compiledAt === "string"
+  )
+));
+
+const derivedLibrary = decodeObject(compileLibraryBuffer("other = |other;\n", {
+  source: "derived.k",
+  libraries: [library]
+}));
+const derivedAliases = extractAliasesFromObject(derivedLibrary);
+assert.match(derivedAliases, /^\$ nat = @/m);
+assert.match(derivedAliases, /^succ = @/m);
+assert.match(derivedAliases, /^other = @/m);
+assert(derivedAliases.indexOf("$ nat = @") < derivedAliases.indexOf("other = @"));
+assert(derivedAliases.indexOf("other = @") < derivedAliases.indexOf("succ = @"));
+
+const aliasSnippet = extractAliasesFromObject({
+  format: "k-object",
+  version: 2,
+  codes: {},
+  rels: {},
+  meta: {
+    "@relB": {
+      type: "rel",
+      origins: [
+        { source: "new.k", name: "times", compiledAt: "2026-04-12T06:08:10.390Z" },
+        { source: "core.k", name: "times", compiledAt: "2026-03-09T06:17:23.390Z" },
+        { source: "other.k", name: "plus", compiledAt: "2026-05-17T06:10:23.390Z" }
+      ]
+    },
+    "@codeB": {
+      type: "code",
+      origins: [
+        { source: "z.k", name: "edges", compiledAt: "2026-03-09T06:17:23.390Z" }
+      ]
+    },
+    "@codeA": {
+      type: "code",
+      origins: [
+        { source: "a.k", name: "bits", compiledAt: "2026-05-17T06:10:23.390Z" }
+      ]
+    }
+  },
+  main: null
+});
+assert.deepEqual(aliasSnippet.split("\n").filter(Boolean), [
+  '$ bits = @codeA; # {"source":"a.k","compiledAt":"2026-05-17T06:10:23.390Z"}',
+  '$ edges = @codeB; # {"source":"z.k","compiledAt":"2026-03-09T06:17:23.390Z"}',
+  'plus = @relB; # {"source":"other.k","compiledAt":"2026-05-17T06:10:23.390Z"}',
+  '# times = @relB; # {"source":"core.k","compiledAt":"2026-03-09T06:17:23.390Z"}',
+  'times = @relB; # {"source":"new.k","compiledAt":"2026-04-12T06:08:10.390Z"}'
+]);
+
 console.log("OK");

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,16 +52,44 @@ 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];
 assert(completions.includes(`:load ${libPath}`));
+completions = completeInput(`:load --no-alias ${tmpDir}/ses`, state)[0];
+assert(completions.includes(`:load --no-alias ${libPath}`));
 
 output = await evaluateInput(`:ko ${koPath} succ`, state);
 assert.equal(output[0], `saved ${koPath} (succ)`);
@@ -88,13 +127,31 @@ assert.match(output[0], /^succ = @/m);
 output = await evaluateInput("succ", reloaded);
 assert.equal(output[0], "{}|succ ?<{} succ, ...>");
 
+const noAliasReloaded = createState();
+output = await evaluateInput(`:load --no-alias ${libPath}`, noAliasReloaded);
+assert.equal(output[0], `loaded ${libPath}`);
+output = await evaluateInput(":codes", noAliasReloaded);
+assert.equal(output[0], "(none)");
+output = await evaluateInput(":rels", noAliasReloaded);
+assert.equal(output[0], "(none)");
+
 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()),