@fraczak/k 6.8.0 → 6.9.0

package/repl.mjs

@@ -14,10 +14,12 @@ import { exportPatternGraph } from "./codecs/runtime/codec.mjs";
 import { patternToPropertyList } from "./codecs/runtime/pattern-json.mjs";
 import codes from "./codes.mjs";
 import { Value, isProduct, isVariant } from "./Value.mjs";
+import { patternFromFilter } from "./codecs/runtime/pattern-k.mjs";
 if (typeof globalThis !== "undefined") {
   globalThis.Value = Value;
   globalThis.isProduct = isProduct;
   globalThis.isVariant = isVariant;
+  globalThis.patternFromFilter = patternFromFilter;
 }
 import { patterns2filters, prettyCode, prettyRel } from "./pretty.mjs";
 import {
@@ -39,11 +41,9 @@ import {
   registerCodec,
   resolveCodec,
   unregisterCodec,
-  BUILTIN_CODECS,
   closedPatternToCodeHash,
-  UNIVERSAL_CODE,
   valueForPattern,
-  matchBuiltinCodec
+  ensureEnveloped
 } from "./repl-codecs.mjs";
 
 const NAME_RE = /^[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*$/;
@@ -349,7 +349,8 @@ function listAliases(aliases) {
 }
 
 function formatCodecOutput(output) {
-  if (Buffer.isBuffer(output)) return output.toString("utf8");
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(output)) return output.toString("utf8");
+  if (typeof Uint8Array !== "undefined" && output instanceof Uint8Array) return new TextDecoder().decode(output);
   return String(output);
 }
 
@@ -357,19 +358,16 @@ function printValue(value, state = null) {
   const lines = [valueWithEnvelopeToK(value)];
   if (!state || value === undefined) return lines[0];
 
-  const codeHash = closedPatternToCodeHash(value.pattern);
-  const codecs = [
-    ...(codeHash ? state.codecs?.[codeHash] || [] : []),
-    ...(state.codecs?.[UNIVERSAL_CODE] || [])
-  ];
-  if (codecs.length === 0) return lines[0];
-  for (const codec of codecs) {
+  const store = state.codecs || {};
+  for (const codec of Object.values(store)) {
     if (typeof codec.print !== "function") continue;
     try {
-      lines.push(`${codec.name}: ${formatCodecOutput(codec.print(value, { codeHash, state }))}`);
-    } catch (error) {
-      if (codec.universal) continue;
-      lines.push(`${codec.name}: <error: ${error.message || String(error)}>`);
+      const output = codec.print(value, { state });
+      if (output != null) {
+        lines.push(`${codec.name}: ${formatCodecOutput(output)}`);
+      }
+    } catch {
+      // Codec cannot format this value; silently skip
     }
   }
   return lines.join("\n");
@@ -649,13 +647,7 @@ function completeCodecCommand(line, argStart, arg, state) {
   const tokenStart = codecLoadPathCompletionStart(argStart, arg);
   if (tokenStart == null) return [[], line];
   const [pathMatches] = completePath(line, tokenStart);
-  const match = arg.match(/^(\s*)load(?:\s+(.*))?$/);
-  const partial = match && match[2] != null ? match[2].trim() : "";
-  const prefix = line.slice(0, tokenStart);
-  const builtinMatches = ["int", "utf8", "json", "ieee"]
-    .filter((name) => name.startsWith(partial))
-    .map((name) => `${prefix}${name}`);
-  return [[...builtinMatches, ...pathMatches], line];
+  return [pathMatches, line];
 }
 
 function resolveTypeHash(state, rawName) {
@@ -785,37 +777,16 @@ function resolveInputPattern(state, rawExpr) {
 }
 
 function completeInputCommand(line, state, argStart, arg) {
-  const match = arg.match(/^(\s*)(\S+)?(\s+)?(\S*)?$/);
-  if (!match) return [[], line];
-  const [, leading, firstToken = "", afterWhitespace = "", secondPartial = ""] = match;
-
-  if (!firstToken || !afterWhitespace) {
-    if (/@[A-Za-z0-9_?!+-]*$/.test(line)) return completeCanonicalCode(line, state);
-    const [types] = completeTypeIdentifier(line, state);
+  const match = arg.match(/^(\s*)(\S*)$/);
+  if (match) {
+    const [, leading, partial] = match;
     const prefix = line.slice(0, argStart + leading.length);
-    const codecMatches = codecNames(state)
-      .filter((name) => name.startsWith(firstToken))
+    const names = codecNames(state);
+    const matches = names
+      .filter((name) => name.startsWith(partial))
       .map((name) => `${prefix}${name}`);
-    return [[...new Set([...types, ...codecMatches])], line];
-  }
-
-  if (firstToken) {
-    const prefix = line.slice(0, argStart + leading.length + firstToken.length + afterWhitespace.length);
-    const names = (() => {
-      try {
-        return codecNames(state, resolveTypeHash(state, firstToken));
-      } catch {
-        return codecNames(state);
-      }
-    })();
-    return [
-      names
-        .filter((name) => name.startsWith(secondPartial))
-        .map((name) => `${prefix}${name}`),
-      line
-    ];
+    return [matches, line];
   }
-
   return [[], line];
 }
 
@@ -905,14 +876,6 @@ function parseLoadArgs(arg, usagePrefix = ":") {
   return { path: arg.trim(), loadAliases: true };
 }
 
-const CODEC_FILES = {
-  int: "arithmetics.k",
-  utf8: "core.k",
-  json: "core.k",
-  ieee: "ieee.k",
-  unit: "core.k"
-};
-
 function normalizeFilePath(p) {
   return p.replace(/\\/g, "/").replace(/^\.\//, "");
 }
@@ -983,24 +946,6 @@ function loadSourceOrKlib(state, targetPath, options = {}) {
   return targetPath;
 }
 
-function ensureCodecDependencies(state, codecTarget) {
-  const norm = normalizeFilePath(codecTarget).toLowerCase();
-  const base = path.basename(norm, path.extname(norm));
-  const depFile = CODEC_FILES[base] || CODEC_FILES[norm];
-  if (!depFile) return null;
-  if (!state.loadedFiles) state.loadedFiles = new Set();
-  const depNormKey = normalizeFilePath(depFile);
-  const baseName = path.basename(depNormKey);
-  const alreadyLoaded = state.loadedFiles.has(depNormKey) ||
-    state.loadedFiles.has(`Examples/${depNormKey}`) ||
-    Array.from(state.loadedFiles).some(f => path.basename(f) === baseName);
-  if (!alreadyLoaded) {
-    loadSourceOrKlib(state, depFile);
-    return depFile;
-  }
-  return null;
-}
-
 function lineForContinuation(line) {
   return line.replace(/\\\s*$/, "");
 }
@@ -1206,13 +1151,10 @@ async function loadCodec(input, state) {
   const [subcommand, ...rest] = trimmed.split(/\s+/);
   switch (subcommand) {
     case "load": {
-      const filePath = rest.join(" ");
-      if (!filePath) throw new Error(":codec load requires a file path or codec name");
-      const autoLoaded = ensureCodecDependencies(state, filePath);
+      const filePath = rest.join(" ").trim();
+      if (!filePath) throw new Error(":codec load requires a file path");
       const registered = await loadCodecModule(state, expandHome(filePath));
-      return registered.map(({ name, codeHash }) =>
-        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
-      );
+      return registered.map(({ name }) => `loaded codec ${name}`);
     }
     case "unload": {
       const codecName = rest.join(" ").trim();
@@ -1222,120 +1164,55 @@ async function loadCodec(input, state) {
       return [`unloaded codec ${codecName}`];
     }
     case "define":
-      throw new Error(":codec define has been removed; use :codec load <name|file> or the Custom Codec Studio UI");
+      throw new Error(":codec define has been removed; all codecs are loaded from files via :codec load <file.mjs>");
     case "list":
       if (rest.length > 0) throw new Error(":codec list does not accept arguments");
       return [listCodecs(state)];
     default: {
-      const autoLoaded = ensureCodecDependencies(state, trimmed);
       const registered = await loadCodecModule(state, expandHome(trimmed));
-      return registered.map(({ name, codeHash }) =>
-        `loaded codec ${name} for ${codeHash === UNIVERSAL_CODE ? "all types" : codeHash}${autoLoaded ? ` (auto-loaded ${autoLoaded})` : ""}`
-      );
+      return registered.map(({ name }) => `loaded codec ${name}`);
     }
   }
 }
 
 async function requestCodecInput(input, state) {
-  const trimmed = input.trim() || "(...)";
-
-  let pattern = null;
-  let codeHash = null;
-  let codecName = null;
-  let targetDisplay = null;
-  let rawExpr = trimmed;
-
-  const isJustCodec = (() => {
-    if (trimmed.startsWith("?") || trimmed.startsWith("$") || trimmed.startsWith("{") || trimmed.startsWith("<") || trimmed.startsWith("(")) {
-      return false;
-    }
-    const allCodecs = codecNames(state);
-    const builtin = matchBuiltinCodec(trimmed);
-    const isCodecName = allCodecs.includes(trimmed) || builtin != null;
-    const isTypeAlias = Boolean(state.typeAliases && state.typeAliases[trimmed]);
-    return isCodecName && !isTypeAlias;
-  })();
-
-  if (isJustCodec) {
-    codecName = trimmed;
-    targetDisplay = trimmed;
-    ensureCodecDependencies(state, codecName);
-    if (!state.codecs?.[codecName] && matchBuiltinCodec(codecName)) {
-      await loadCodecModule(state, codecName);
-    }
-    if (state.typeAliases?.[codecName]) {
-      codeHash = state.typeAliases[codecName];
-      pattern = codeHashToPattern(codeHash, codes.find);
-      targetDisplay = codeHash;
-    }
-  } else {
-    let splitPattern = null;
-    let splitCodec = null;
-
-    const split = trimmed.match(/^(.*\S)\s+([a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*)$/);
-    if (split && split[1].trim() !== "?" && split[1].trim() !== "$") {
-      splitPattern = split[1];
-      splitCodec = split[2];
-    }
+  let trimmed = input.trim();
+  if (!trimmed) {
+    const loaded = Object.keys(state.codecs || {});
+    const loadedStr = loaded.length > 0 ? `Loaded: ${loaded.join(", ")}` : "None loaded";
+    return [
+      "Usage: :input <codec.mjs> [text]",
+      `Loaded codecs: ${loadedStr}`
+    ];
+  }
 
-    if (splitCodec) {
-      try {
-        const resolved = resolveInputPattern(state, splitPattern);
-        pattern = resolved.pattern;
-        codeHash = resolved.codeHash;
-        codecName = splitCodec;
-        targetDisplay = resolved.display;
-        rawExpr = splitPattern;
-      } catch (patternErr) {
-        const resolved = resolveInputPattern(state, trimmed);
-        pattern = resolved.pattern;
-        codeHash = resolved.codeHash;
-        targetDisplay = resolved.display;
-        rawExpr = trimmed;
-      }
-    } else {
-      const resolved = resolveInputPattern(state, trimmed);
-      pattern = resolved.pattern;
-      codeHash = resolved.codeHash;
-      targetDisplay = resolved.display;
-      rawExpr = trimmed;
-    }
+  if (trimmed.startsWith("$")) {
+    trimmed = trimmed.slice(1).trim();
   }
 
-  const explicitCodec = Boolean(codecName);
-  if (!codecName && codeHash) {
-    for (const [alias, hash] of Object.entries(state.typeAliases || {})) {
-      if (hash === codeHash && (matchBuiltinCodec(alias) || codecNames(state).includes(alias))) {
-        codecName = alias;
-        break;
-      }
-    }
+  const match = trimmed.match(/^([a-zA-Z0-9_?!+.-]+)(?:\s+([\s\S]*))?$/);
+  if (!match) {
+    throw new Error("Invalid :input syntax. Usage: :input <codec.mjs> [text]");
   }
 
-  if (codecName) {
-    ensureCodecDependencies(state, codecName);
-    if (!state.codecs?.[codecName] && matchBuiltinCodec(codecName)) {
-      await loadCodecModule(state, codecName);
-    }
-  } else {
-    const hasExactCodec = Boolean(codeHash && state.codecs?.[codeHash]?.some((c) => typeof c.parse === "function"));
-    const hasUniversal = Boolean(state.codecs?.[UNIVERSAL_CODE]?.some((c) => typeof c.parse === "function"));
-    if (!hasExactCodec && !hasUniversal && matchBuiltinCodec("json")) {
-      await loadCodecModule(state, "json");
-    }
+  const codecName = match[1];
+  const inlineText = match[2];
+
+  const codec = resolveCodec(state, codecName, "parse");
+
+  if (inlineText !== undefined) {
+    const parsed = await codec.parse(inlineText, { state, codecName: codec.name });
+    const value = ensureEnveloped(parsed, codec);
+    state.value = value;
+    state.lastResult = value;
+    return [printValue(value, state)];
   }
 
-  const codec = resolveCodec(state, codeHash, codecName, "parse");
   state.pendingInput = {
-    pattern,
-    codeHash,
     codecName: codec.name,
-    promptName: codec.name,
-    rawExpr
+    promptName: codec.name
   };
-
-  const usingPart = explicitCodec && codecName && codecName !== targetDisplay ? ` using ${codecName}` : "";
-  return [`input ${targetDisplay}${usingPart}: enter value text`];
+  return [];
 }
 
 async function consumeCodecInput(input, state) {
@@ -1344,14 +1221,12 @@ async function consumeCodecInput(input, state) {
   state.pendingInput = null;
 
   restoreCodes(state);
-  const codec = resolveCodec(state, pending.codeHash, pending.codecName, "parse");
-  const pattern = pending.pattern || (pending.codeHash ? codeHashToPattern(pending.codeHash, codes.find) : null);
+  const codec = resolveCodec(state, pending.codecName, "parse");
   const parsed = await codec.parse(input, {
-    codeHash: pending.codeHash,
-    pattern,
-    state
+    state,
+    codecName: codec.name
   });
-  const value = valueForPattern(parsed, pattern, input, codec.name);
+  const value = ensureEnveloped(parsed, codec);
   state.value = value;
   state.lastResult = value;
   return [printValue(value, state)];
@@ -1478,10 +1353,10 @@ function helpText() {
     ":type name           show type definition",
     ":codes               list type aliases",
     ":rels                list relation aliases",
-    ":codec load file     load a REPL codec module (or built-in: int, utf8, json, ieee, unit)",
+    ":codec load file     load a codec module from file (e.g. :codec load codecs/int.mjs)",
     ":codec unload name   unload a registered codec",
     ":codec list          list loaded codecs (or simply :codecs)",
-    ":input [<filter=(...)> [codec]]  read next line as codec input",
+    ":input <codec.mjs> [text]  parse input using specified codec",
     ":load [--no-alias] file",
     "                     load .k source or .klib",
     ":klib file           export state as a library",
@@ -1635,13 +1510,14 @@ export {
   resolveInputPattern,
   valueForPattern,
   codeHashToPattern,
-  BUILTIN_CODECS,
   printValue,
   promptForState,
   propertyListToFilter,
   savedLibrary,
   loadSourceOrKlib,
-  ensureCodecDependencies,
   valueToK,
-  formatDuration
+  formatDuration,
+  codecNames,
+  ensureEnveloped,
+  patternFromFilter
 };