@fraczak/k 6.0.0 → 6.0.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@fraczak/k",
-    "version": "6.0.0",
+    "version": "6.0.1",
     "description": "k — a language for composing first-order partial functions over algebraic data types (products and tagged unions); includes runtime, type derivation, REPL, and codec toolchain",
     "main": "index.mjs",
     "scripts": {
@@ -10,22 +10,19 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/fraczak/k.git"
-    },
-    "publishConfig": {
-        "access": "public"
+        "url": "https://github.com/fraczak/k.git"
     },
     "author": "Wojciech Fraczak",
     "license": "ISC",
     "bin": {
-        "k": "k.mjs",
-        "k-compile-object": "objects/compile.mjs",
-        "k-decompile-object": "objects/decompile.mjs",
-        "k-parse": "codecs/k-parse.mjs",
-        "k-pattern": "codecs/k-pattern.mjs",
-        "k-print": "codecs/k-print.mjs",
-        "k-repl": "repl2.mjs",
-        "k-repl2": "repl2.mjs"
+        "k": "./k.mjs",
+        "k-compile-object": "./objects/compile.mjs",
+        "k-decompile-object": "./objects/decompile.mjs",
+        "k-parse": "./codecs/k-parse.mjs",
+        "k-pattern": "./codecs/k-pattern.mjs",
+        "k-print": "./codecs/k-print.mjs",
+        "k-repl": "./repl2.mjs",
+        "k-repl2": "./repl2.mjs"
     },
     "devDependencies": {
         "jiwson": "^0.1.2"

package/repl2.mjs

@@ -376,6 +376,15 @@ function createCompleter(state) {
   return (line) => completeInput(line, state);
 }
 
+function isMainEntrypoint(entryArg = argv[1]) {
+  if (!entryArg) return false;
+  try {
+    return fs.realpathSync(entryArg) === fs.realpathSync(fileURLToPath(import.meta.url));
+  } catch {
+    return false;
+  }
+}
+
 function ensureSemicolon(source) {
   return source.trim().endsWith(";") ? source : `${source};`;
 }
@@ -635,7 +644,7 @@ function startRepl() {
   });
 }
 
-if (argv[1] && fileURLToPath(import.meta.url) === argv[1]) {
+if (isMainEntrypoint()) {
   startRepl();
 }
 
@@ -646,6 +655,7 @@ export {
   createState,
   evaluateInput,
   helpText,
+  isMainEntrypoint,
   printValue,
   propertyListToFilter,
   valueToK

package/test-repl2.mjs

@@ -2,8 +2,9 @@ import assert from "node:assert";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { fileURLToPath } from "node:url";
 
-import { completeInput, createState, evaluateInput } from "./repl2.mjs";
+import { completeInput, createState, evaluateInput, isMainEntrypoint } from "./repl2.mjs";
 import { decodeObject, objectToFunction } from "./object.mjs";
 import { Product } from "./Value.mjs";
 
@@ -44,6 +45,7 @@ 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);
 assert.equal(output[0], `saved ${libPath}`);
 
@@ -65,6 +67,14 @@ assert.match(output[0], /^nat = @/m);
 output = await evaluateInput(":rels", loadedSource);
 assert.match(output[0], /^succ = @/m);
 
+const replPath = fileURLToPath(new URL("./repl2.mjs", import.meta.url));
+try {
+  fs.rmSync(symlinkPath, { force: true });
+} catch {}
+fs.symlinkSync(replPath, symlinkPath);
+fs.chmodSync(replPath, 0o755);
+assert.equal(isMainEntrypoint(symlinkPath), true);
+
 const reloaded = createState();
 output = await evaluateInput(`:load ${libPath}`, reloaded);
 assert.equal(output[0], `loaded ${libPath}`);
@@ -92,4 +102,5 @@ await assert.rejects(
 );
 
 fs.rmSync(tmpDir, { recursive: true, force: true });
+fs.rmSync(symlinkPath, { force: true });
 console.log("OK");

package/type_registry/registry.mjs~

@@ -0,0 +1,105 @@
+import http from 'http';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import codes from '../codes.mjs';
+import { parse } from './typeParser.mjs';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const REGISTRY_FILE = path.join(__dirname, 'registry.json');
+const PORT = 3001;
+
+// Load existing registry if it exists
+if (fs.existsSync(REGISTRY_FILE)) {
+    console.log('Loading existing registry...');
+    try {
+        const data = fs.readFileSync(REGISTRY_FILE, 'utf8');
+        const json = JSON.parse(data);
+        codes.load(json);
+        console.log(`Loaded ${Object.keys(json).length} types.`);
+    } catch (err) {
+        console.error('Error loading registry:', err);
+    }
+} else {
+    console.log('No existing registry found. Starting fresh.');
+}
+
+const server = http.createServer((req, res) => {
+    // Helper to send JSON response
+    const sendJSON = (data, status = 200) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify(data));
+    };
+
+    // Helper to send Error
+    const sendError = (message, status = 400) => {
+        res.writeHead(status, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ error: message }));
+    };
+
+    // Route: POST
+    if (req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => {
+            body += chunk.toString();
+        });
+        req.on('end', () => {
+            try {
+                // 1. Parse the input string using the Jison parser
+                // The parser expects a string of type definitions
+                console.log("Received body:", body);
+                const definitions = parse(body);
+                console.log("Parsed definitions:", JSON.stringify(definitions, null, 2));
+
+                // 2. Register the parsed codes
+                // codes.register returns the representatives map { temp_name: canonical_hash }
+                const representatives = codes.register(definitions);
+
+                // Filter out generated names (_gen_...) and canonical names (@...)
+                const filteredRepresentatives = Object.fromEntries(
+                    Object.entries(representatives).filter(([key, value]) => 
+                        !key.startsWith('_gen_') && !key.startsWith('@')
+                    )
+                );
+
+                // 3. Save to disk
+                const dump = codes.dump();
+                fs.writeFileSync(REGISTRY_FILE, JSON.stringify(dump, null, 2));
+
+                // 4. Return the mapping
+                sendJSON(filteredRepresentatives);
+
+            } catch (err) {
+                console.error(err);
+                sendError(`Registration failed: ${err.message}`);
+            }
+        });
+    }
+    // Route: GET 
+    else if (req.method === 'GET') {
+        const typeId = req.url.split('/').pop();
+        console.log("Requested type ID:", typeId);
+        if (!typeId) {
+            sendError('Missing type ID');
+            return;
+        }
+        // Decode URI component in case @ is encoded
+        const decodedId = decodeURIComponent(typeId);
+        console.log("Decoded type ID:", decodedId);
+        
+        const typeDef = codes.find(decodedId);
+        if (typeDef.code === 'undefined') {
+            sendError('Type not found', 404);
+        } else {
+            sendJSON(typeDef);
+        }
+    }
+    // 404 Not Found
+    else {
+        sendError('Not Found', 404);
+    }
+});
+
+server.listen(PORT, () => {
+    console.log(`Type Registry running at http://localhost:${PORT}/`);
+});

package/type_registry/typeParser.jison~

@@ -0,0 +1,132 @@
+%{
+
+let defs = {};
+let genCount = 0;
+let genNameId;
+
+function genName() {
+  return `_gen_${genCount++}`;
+}
+
+function fromEscString(escString) {
+  const isSingleQuoted = escString.startsWith("'");
+  let str = escString.substring(1, escString.length - 1);
+  if (isSingleQuoted) {
+    str = str.replace(/\\'/g, "'");
+  } else {
+    str = str.replace(/\\"/g, '"');
+  }
+  str = str.replace(/\\\\/g, '\\');
+  str = str.replace(/\\\//g, '/');
+  str = str.replace(/\\b/g, '\b');
+  str = str.replace(/\\f/g, '\f');
+  str = str.replace(/\\n/g, '\n');
+  str = str.replace(/\\r/g, '\r');
+  str = str.replace(/\\t/g, '\t');
+  str = str.replace(/\\u([\dA-F]{4})/gi, (match, p1) => String.fromCharCode(parseInt(p1, 16)));
+
+  return str;
+}
+
+%}
+
+%lex
+
+%%
+\s+                                            /* blanks */
+"<"                                            return 'LA';
+">"                                            return 'RA';
+"{"                                            return 'LC';
+"}"                                            return 'RC';
+"="                                            return 'EQ';
+","                                            return 'COMMA';
+";"                                            return 'SC';
+"@"                                            return 'AT';
+"$"                                            return 'DOLLAR';
+\"([^"\\]|\\(.|\n))*\"|\'([^'\\]|\\(.|\n))*\'  return 'STRING';
+[a-zA-Z0-9_+-][a-zA-Z0-9_?!+-]*                return 'NAME';
+<<EOF>>                                        return 'EOF';
+.                                              return 'INVALID';
+
+/lex
+
+%token NAME STRING
+%token LA RA LC RC EQ COMMA SC AT DOLLAR
+%token EOF
+
+%start expressions
+
+%%
+
+expressions
+    : initialize_defs definitions EOF
+        { return defs; }
+    ;
+
+initialize_defs
+    : /* empty */
+        { defs = {}; genCount = 0; }
+    ;
+
+definitions
+    : definition
+    | definitions definition
+    ;
+
+definition
+    : DOLLAR name EQ LA field_list RA SC
+        { defs[$2] = { code: 'union', union: $5 }; }
+    | DOLLAR name EQ LC field_list RC SC
+        { defs[$2] = { code: 'product', product: $5 }; }
+    ;
+
+type_expr
+    : LA field_list RA
+        { 
+          genNameId = genName();
+          defs[genNameId] = { code: 'union', union: $2 }; 
+          $$ = genNameId;
+        }
+    | LC field_list RC
+        { 
+          genNameId = genName();
+          defs[genNameId] = { code: 'product', product: $2 }; 
+          $$ = genNameId;
+        }
+    | ref
+        { $$ = $1; }
+    ;
+
+ref
+    : name
+        { $$ = $1; }
+    | AT name
+        { $$ = '@' + $2; }
+    ;
+
+field_list
+    : /* empty */
+        { $$ = {}; }
+    | field
+        { $$ = {}; $$[$1.label] = $1.type; }
+    | field_list COMMA field
+        { $$ = $1; $$[$3.label] = $3.type; }
+    ;
+
+field
+    : type_expr label
+        { $$ = { type: $1, label: $2 }; }
+    ;
+
+label
+    : name
+        { $$ = $1; }
+    | str
+        { $$ = $1; }
+    ;
+
+name: NAME { $$ = yytext; };
+str: STRING { $$ = fromEscString(yytext); };
+
+%%
+