githolon 0.1.6 → 0.2.1

package/dist/cli.mjs

@@ -2,8 +2,9 @@
 
 // src/cli.ts
 import { spawnSync as spawnSync3 } from "node:child_process";
+import { existsSync as existsSync4, readdirSync as readdirSync3, readFileSync as readFileSync4 } from "node:fs";
 import { createRequire } from "node:module";
-import { dirname as dirname2, join as join4 } from "node:path";
+import { dirname as dirname2, join as join4, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 
 // src/generate.ts
@@ -78,8 +79,8 @@ export const ${n.pascal} = aggregate("${n.pascal}", {
 function domainTemplate(raw) {
   const n = namesFor(raw);
   return `${HEADER(raw, "domain")}
-import { z } from "zod";
 import {
+  z,
   aggregate,
   directive,
   t,
@@ -140,8 +141,7 @@ ${aggregateBlock(n)}
 function intentTemplate(raw) {
   const n = namesFor(raw);
   return `${HEADER(raw, "intent (directive)")}
-import { z } from "zod";
-import { aggregate, directive, t, Conflict, set } from "@githolon/dsl";
+import { z, aggregate, directive, t, Conflict, set } from "@githolon/dsl";
 
 // Stub target \u2014 in a real domain, import the existing aggregate handle instead.
 export const ${n.pascal} = aggregate("${n.pascal}", {
@@ -332,12 +332,23 @@ async function logout() {
 }
 async function wsCreate(name, opts) {
   const cloud = cloudBase(opts.cloud);
-  const principal = opts.principal ?? await sessionToken().catch((e) => (err(e.message), void 0)) ?? loadCreds().principal;
+  let principal = opts.principal ?? await sessionToken().catch((e) => (err(e.message), void 0)) ?? loadCreds().principal;
   if (principal === void 0) {
-    err(
-      "a birth needs a principal \u2014 githolon login --agent (self-onboarding),\nor pass --principal <your-auth-uid or access token> (saved as the default)"
-    );
-    return 1;
+    const d2 = await gotrue("/auth/v1/signup", "{}");
+    const s = sessionFromGotrue(d2);
+    if (s === void 0) {
+      err(
+        `a birth needs a principal, and automatic agent login failed: ${d2.error_description ?? d2.error ?? d2.msg ?? JSON.stringify(d2)}
+  githolon login --agent (self-onboarding), githolon login --token <refresh>,
+  or pass --principal <your-auth-uid or access token> (saved as the default)`
+      );
+      return 1;
+    }
+    saveSession(s);
+    out(`no principal on file \u2014 self-onboarded an anonymous agent identity (githolon login --agent)`);
+    out(`  principal uid ${s.uid} (linkable to a full account later)`);
+    out(`  session saved \u2192 ${credsPath()} (auto-refreshed; births ride x-nomos-auth)`);
+    principal = s.accessToken;
   }
   const r = await fetch(`${cloud}/v1/workspaces/${name}`, {
     method: "POST",
@@ -587,7 +598,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
     const rel = p.slice(mount.length + 1).replace(/\/+$/, "");
     return rel === "" ? [] : rel.split("/");
   }
-  function resolve(ps) {
+  function resolve2(ps) {
     let cur = root;
     for (const part of ps) {
       if (!isDir(cur)) return null;
@@ -597,11 +608,11 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
     }
     return cur;
   }
-  const parent = (ps) => resolve(ps.slice(0, -1));
+  const parent = (ps) => resolve2(ps.slice(0, -1));
   const leaf = (ps) => ps[ps.length - 1];
   const promises = {
     async readFile(p, opts) {
-      const n = resolve(parts(p));
+      const n = resolve2(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       if (isDir(n)) throw fsErr("EISDIR", p);
       const data = n.data ?? new Uint8Array(0);
@@ -620,7 +631,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
       if (!isDir(par) || !par.contents.delete(leaf(ps))) throw fsErr("ENOENT", p);
     },
     async readdir(p) {
-      const n = resolve(parts(p));
+      const n = resolve2(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       if (!isDir(n)) throw fsErr("ENOTDIR", p);
       return [...n.contents.keys()];
@@ -640,7 +651,7 @@ function makeGitFs(preopen, mount, { File: File3, Directory: Directory3 }) {
       return promises.lstat(p);
     },
     async lstat(p) {
-      const n = resolve(parts(p));
+      const n = resolve2(parts(p));
       if (n === null) throw fsErr("ENOENT", p);
       const dir = isDir(n);
       return {
@@ -949,6 +960,8 @@ var USAGE = `githolon \u2014 the Nomos developer CLI
 
 Authoring:
   githolon compile  [compiler args]                       compile the package by ./nomos.package.mjs
+  githolon proof    [build/<name>.proof.mts]              run the proof GENERATED from your law, live
+                                                       (every compile emits it; ALL GREEN or it names the jam)
   githolon generate <domain|aggregate|intent> <name> [options]
   githolon g        <domain|aggregate|intent> <name> [options]
 
@@ -960,6 +973,7 @@ Identity (~/.holon/credentials.json \u2014 sessions auto-refresh):
 
 Nomos Cloud (secrets live in ~/.holon/credentials.json \u2014 never copy one by hand):
   githolon ws create <name> [--principal <uid|token>]     birth a workspace; SAVES its one-time secret
+                                                       (no identity on file? it self-onboards an agent login)
   githolon ws status <name>                               workspace status (lineage, phase, verdicts)
   githolon ws retire <name>                               retire a workspace (owner) \u2014 quota freed; data retained
                                                        per the license; reads keep serving
@@ -1051,11 +1065,64 @@ function runCompile(args) {
   const r = spawnSync3(process.execPath, [launcher, ...args], { stdio: "inherit", cwd: process.cwd() });
   return r.status ?? 1;
 }
+function runProof(args) {
+  const refuse = (m) => {
+    process.stderr.write(`error: ${m}
+`);
+    return 1;
+  };
+  const explicit = args.find((a) => !a.startsWith("--"));
+  let proofPath;
+  if (explicit !== void 0) {
+    proofPath = resolve(process.cwd(), explicit);
+    if (!existsSync4(proofPath)) return refuse(`proof not found: ${proofPath} \u2014 run \`githolon compile\` to (re)generate it`);
+  } else {
+    const buildDir = join4(process.cwd(), "build");
+    if (!existsSync4(buildDir)) {
+      return refuse("no build/ directory here \u2014 run `githolon compile` first (every compile generates build/<name>.proof.mts from your law)");
+    }
+    const proofs = readdirSync3(buildDir).filter((f) => f.endsWith(".proof.mts"));
+    if (proofs.length === 0) {
+      return refuse("no build/*.proof.mts found \u2014 run `githolon compile` (every compile generates the proof from your law; the compile summary says why when it can't)");
+    }
+    if (proofs.length > 1) {
+      return refuse(`found ${proofs.length} proofs (${proofs.join(", ")}) \u2014 name one: githolon proof build/<name>.proof.mts`);
+    }
+    proofPath = join4(buildDir, proofs[0]);
+  }
+  const resolvePkgDir = (name, fromDir) => {
+    try {
+      return dirname2(createRequire(pathToFileURL(join4(fromDir, "noop.js"))).resolve(`${name}/package.json`));
+    } catch {
+      return void 0;
+    }
+  };
+  const dslDir = (() => {
+    try {
+      return dirname2(createRequire(pathToFileURL(join4(process.cwd(), "noop.js"))).resolve("@githolon/dsl/package.json"));
+    } catch {
+      try {
+        return dirname2(createRequire(import.meta.url).resolve("@githolon/dsl/package.json"));
+      } catch {
+        return void 0;
+      }
+    }
+  })();
+  const tsxDir = resolvePkgDir("tsx", process.cwd()) ?? (dslDir !== void 0 ? resolvePkgDir("tsx", dslDir) : void 0);
+  if (tsxDir === void 0) {
+    return refuse("tsx not found \u2014 add @githolon/dsl to your project's dependencies (tsx rides along) and npm install");
+  }
+  const tsxPkg = JSON.parse(readFileSync4(join4(tsxDir, "package.json"), "utf8"));
+  const tsxBinRel = typeof tsxPkg.bin === "string" ? tsxPkg.bin : tsxPkg.bin?.["tsx"];
+  const tsxCli = join4(tsxDir, tsxBinRel ?? "dist/cli.mjs");
+  const r = spawnSync3(process.execPath, [tsxCli, proofPath], { stdio: "inherit", cwd: process.cwd() });
+  return r.status ?? 1;
+}
 function parseArgs(argv) {
   const [command, ...rest] = argv;
   if (command !== "generate" && command !== "g") {
     throw new Error(
-      `Unknown command '${command ?? "(none)"}'. Expected compile | generate | ws | deploy | secret.`
+      `Unknown command '${command ?? "(none)"}'. Expected compile | proof | generate | ws | deploy | secret.`
     );
   }
   let outDir = DEFAULT_OUT;
@@ -1101,6 +1168,9 @@ async function main(argv) {
   if (argv[0] === "compile") {
     return runCompile(argv.slice(1));
   }
+  if (argv[0] === "proof") {
+    return runProof(argv.slice(1));
+  }
   if (argv[0] === "ws" || argv[0] === "deploy" || argv[0] === "secret") {
     return runCloud(argv);
   }

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "githolon",
-  "version": "0.1.6",
+  "version": "0.2.1",
   "type": "module",
-  "description": "githolon — the Nomos developer CLI: Rails-style generators for @githolon/dsl domains + the package compiler. Kernel-independent.",
+  "description": "githolon \u2014 the Nomos developer CLI: Rails-style generators for @githolon/dsl domains + the package compiler. Kernel-independent.",
   "license": "SEE LICENSE IN LICENSE.md",
   "repository": {
     "type": "git",
@@ -27,7 +27,7 @@
   },
   "dependencies": {
     "@bjorn3/browser_wasi_shim": "0.4.2",
-    "@githolon/dsl": "^0.1.3",
+    "@githolon/dsl": "^0.2.1",
     "isomorphic-git": "^1.38.4"
   },
   "devDependencies": {