naive-framework 0.1.0 → 0.3.0

package/schema/money-summary.schema.json

@@ -0,0 +1,138 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "money-summary.schema.json",
+  "title": "Money summary",
+  "description": "The money package's summary (money/_summary.json, EE-070): cash, monthly flows and runway as of the last sync from the system of record (Rho), the one money record that is versioned and the only one an agent or a trace sees. source says whether it came from Rho's sandbox, a saved fixture, or the founder's live account.",
+  "type": "object",
+  "required": [
+    "source",
+    "synced_at",
+    "as_of",
+    "cash"
+  ],
+  "additionalProperties": false,
+  "properties": {
+    "source": {
+      "type": "string",
+      "description": "rho-sandbox, rho-live, or a fixture's name"
+    },
+    "business": {
+      "type": "string"
+    },
+    "synced_at": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "as_of": {
+      "type": "string",
+      "format": "date-time"
+    },
+    "window": {
+      "type": "object",
+      "required": [
+        "from",
+        "to"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "from": {
+          "type": "string",
+          "format": "date-time"
+        },
+        "to": {
+          "type": "string",
+          "format": "date-time"
+        }
+      }
+    },
+    "cash": {
+      "type": "object",
+      "required": [
+        "amount",
+        "currency"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "amount": {
+          "type": "integer",
+          "description": "Minor units (cents for USD), as the source returns them"
+        },
+        "currency": {
+          "type": "string",
+          "pattern": "^[A-Z]{3}$"
+        }
+      }
+    },
+    "monthly_inflow": {
+      "type": "object",
+      "required": [
+        "amount",
+        "currency"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "amount": {
+          "type": "integer",
+          "description": "Minor units (cents for USD), as the source returns them"
+        },
+        "currency": {
+          "type": "string",
+          "pattern": "^[A-Z]{3}$"
+        }
+      }
+    },
+    "monthly_outflow": {
+      "type": "object",
+      "required": [
+        "amount",
+        "currency"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "amount": {
+          "type": "integer",
+          "description": "Minor units (cents for USD), as the source returns them"
+        },
+        "currency": {
+          "type": "string",
+          "pattern": "^[A-Z]{3}$"
+        }
+      }
+    },
+    "monthly_net": {
+      "type": "object",
+      "required": [
+        "amount",
+        "currency"
+      ],
+      "additionalProperties": false,
+      "properties": {
+        "amount": {
+          "type": "integer",
+          "description": "Minor units (cents for USD), as the source returns them"
+        },
+        "currency": {
+          "type": "string",
+          "pattern": "^[A-Z]{3}$"
+        }
+      }
+    },
+    "runway_months": {
+      "type": [
+        "number",
+        "null"
+      ]
+    },
+    "accounts": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "transactions": {
+      "type": "integer",
+      "minimum": 0
+    },
+    "note": {
+      "type": "string"
+    }
+  }
+}

package/schema/naive-config.mjs

@@ -0,0 +1,166 @@
+// naive.config.json (P-2, like next.config.js): a venture's overrides to Naive's defaults. Every
+// field is optional; what a venture leaves out keeps the default here. The file holds the gate's
+// static rules (X-3, X-5, X-6), function owners (X-2), check settings (P-7, like
+// eslint.config.mjs), thresholds, which System 1 questions run, pinned package versions (U-4) and
+// how strictly the acting role is checked (M-18). Shape: schema/naive-config.schema.json. Checked
+// by node schema/check-config.mjs <venture dir>.
+//
+// Reading the config never calls a model or the network: it is files only, so the gate can read it
+// on every write.
+
+import { existsSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { ventureFile } from "./venture-paths.mjs";
+
+const repo = new URL("..", import.meta.url).pathname;
+const load = (p) => JSON.parse(readFileSync(p, "utf8"));
+export const CONFIG = "naive.config.json";
+
+/** The defaults a venture overrides. Arrays and scalars are replaced; objects are merged key by key. */
+export const DEFAULTS = Object.freeze({
+  gate: { fail_closed: [], rules: [], packages: true, variants: false },
+  owners: {},
+  checks: { off: [], warn: [] },
+  thresholds: { confidence: 0.7, "idea-map": load(join(repo, "purpose/frameworks/idea-map/conventions.json")).threshold },
+  questions: {},
+  packages: {},
+  acting: { unknown_roles: "allow" },
+});
+
+const isObj = (x) => x && typeof x === "object" && !Array.isArray(x);
+function merge(base, over) {
+  if (!isObj(base) || !isObj(over)) return over === undefined ? structuredClone(base) : structuredClone(over);
+  const out = structuredClone(base);
+  for (const [k, v] of Object.entries(over)) out[k] = k in base ? merge(base[k], v) : structuredClone(v);
+  return out;
+}
+
+/** The venture's naive.config.json as written, or {} when it has none. A file that is not JSON throws, naming the file. */
+export function rawConfig(dir) {
+  const f = dir && ventureFile(dir, CONFIG);
+  if (!f || !existsSync(f)) return {};
+  try { return load(f); } catch (e) { throw new Error(`${CONFIG} is not valid JSON: ${e.message}`); }
+}
+
+/** The resolved config: the defaults with the venture's overrides on top. */
+export function configFor(dir) {
+  return merge(DEFAULTS, rawConfig(dir));
+}
+
+/** A threshold by name, from the config, else the fallback. */
+export function threshold(config, name, fallback) {
+  const t = config?.thresholds?.[name];
+  return typeof t === "number" ? t : fallback;
+}
+
+/** Check settings (P-7): each check with its mode, run, warn or off. */
+export function checksFor(config, checks) {
+  const off = new Set(config?.checks?.off ?? []), warn = new Set(config?.checks?.warn ?? []);
+  return checks.map((check) => ({ check, mode: off.has(check) ? "off" : warn.has(check) ? "warn" : "run" }));
+}
+
+// A question's kind is its key before the colon (dept.legal:i-01 is dept.legal). A pattern may end in *.
+export const questionKind = (key) => key.split(":")[0];
+const kindMatches = (pattern, kind) => pattern.endsWith("*") ? kind.startsWith(pattern.slice(0, -1)) : kind === pattern;
+
+/** Whether a System 1 question runs, for a framework (idea-map). */
+export function questionOn(config, framework, key) {
+  return !(config?.questions?.[framework]?.off ?? []).some((p) => kindMatches(p, questionKind(key)));
+}
+
+/** A System 1 request ({ state, model, questions }) with the questions the config turns off left out. */
+export function questionsFor(request, config, framework) {
+  const questions = Object.fromEntries(Object.entries(request.questions ?? {}).filter(([k]) => questionOn(config, framework, k)));
+  const off = Object.keys(request.questions ?? {}).length - Object.keys(questions).length;
+  return { ...request, questions, ...(off ? { questions_off: off } : {}) };
+}
+
+/** System 1 answers limited to the questions that run (an answer to a question turned off is ignored). */
+export function answersFor(answers, config, framework) {
+  return Object.fromEntries(Object.entries(answers ?? {}).filter(([k]) => questionOn(config, framework, k)));
+}
+
+// Package definitions, read once per process: they are framework files and do not change under a running gate.
+let pkgCache = null;
+export function packageDefs() {
+  if (pkgCache) return pkgCache;
+  const dir = join(repo, "packages");
+  const catalog = existsSync(join(dir, "catalog.json")) ? load(join(dir, "catalog.json")) : {};
+  pkgCache = existsSync(dir) ? readdirSync(dir).filter((n) => existsSync(join(dir, n, "package.json"))).sort().map((n) => {
+    const p = load(join(dir, n, "package.json"));
+    // A package without its own version is versioned with the catalog it ships in.
+    return { ...p, folder: n, version: p.version ?? catalog.version ?? "0.0.0" };
+  }) : [];
+  return pkgCache;
+}
+
+/** Installed package versions: name to version. */
+export function installed() {
+  return Object.fromEntries(packageDefs().map((p) => [p.name, p.version]));
+}
+
+/** The packages that hold a record type: its home (required or optional) first, then any that lists it in records. */
+export function packagesOf(recordType) {
+  if (!recordType) return [];
+  const defs = packageDefs();
+  const home = defs.filter((p) => [...(p.required ?? []), ...(p.optional ?? [])].includes(recordType));
+  const listed = defs.filter((p) => (p.records ?? []).includes(recordType) && !home.includes(p));
+  return [...home, ...listed];
+}
+
+/** The function (department) a record type belongs to: its home package's department. */
+export function functionOf(recordType) {
+  return packagesOf(recordType).find((p) => p.department)?.department ?? null;
+}
+
+/** Pins that do not match what is installed: { package, pinned, installed } (installed null for an unknown package). */
+export function pinProblems(config) {
+  const have = installed();
+  return Object.entries(pins(config ?? {})).filter(([n, v]) => have[n] !== v.version).map(([n, v]) => ({ package: n, pinned: v.version, installed: have[n] ?? null }));
+}
+
+/** The pins that block a write to a record type: its packages pinned to a version other than the installed one. */
+export function pinsBlocking(config, recordType) {
+  const bad = new Map(pinProblems(config).map((p) => [p.package, p]));
+  return packagesOf(recordType).map((p) => bad.get(p.name)).filter(Boolean);
+}
+
+// A venture's naive.config.json (EE-073): the framework's defaults, overridden for one venture.
+// The gate reads `gate` (schema/gate.mjs). Upgrades read and write the pins (EE-076, U-1 to U-5):
+//
+//   naive      { version, channel }   the framework version the venture is on, and its channel
+//                                     (stable, or canary for experimental packages)
+//   packages   { <name>: { version, early?, channel? } }   the package versions it is pinned to; early
+//                                     marks a later phase's package adopted before its phase. A bare
+//                                     version string ("0.3.0") is read as { version }.
+//   triggers   [ ... ]                what starts the next step on an event (schema/triggers.mjs)
+//   kits       [ <name> ]             Mentura kits whose automations this venture turns on
+//
+// Every other key is kept as it is. Nothing here calls a model or the network.
+
+/** The venture's naive.config.json, or {} when it has none. A file that is not JSON throws. */
+export function readConfig(dir) {
+  const f = ventureFile(dir, CONFIG);
+  if (!existsSync(f)) return {};
+  try { return JSON.parse(readFileSync(f, "utf8")); }
+  catch (e) { throw new Error(`${CONFIG} is not valid JSON: ${e.message}`); }
+}
+
+/** Writes the config back, keys in a stable order: naive, packages, kits, triggers, gate, then the rest. */
+export function writeConfig(dir, cfg) {
+  const order = ["naive", "packages", "kits", "triggers", "gate"];
+  const out = Object.fromEntries([...order.filter((k) => cfg[k] !== undefined).map((k) => [k, cfg[k]]), ...Object.entries(cfg).filter(([k]) => !order.includes(k))]);
+  writeFileSync(ventureFile(dir, CONFIG), JSON.stringify(out, null, 2) + "\n");
+  return out;
+}
+
+/** The pinned packages as { name: { version, early, channel } }. */
+export function pins(cfg) {
+  return Object.fromEntries(Object.entries(cfg.packages ?? {}).map(([k, v]) => [k, typeof v === "string" ? { version: v } : { ...v }]));
+}
+
+/** The names of the packages adopted early (U-5): open now whatever their phase prior says. */
+export function adopted(dir) {
+  try { return new Set(Object.entries(pins(readConfig(dir))).filter(([, p]) => p.early).map(([k]) => k)); }
+  catch { return new Set(); }
+}

package/schema/naive-config.schema.json

@@ -0,0 +1,268 @@
+{
+  "$schema": "https://json-schema.org/draft/2020-12/schema",
+  "$id": "naive-config.schema.json",
+  "title": "naive.config.json",
+  "description": "A venture's overrides to Naive's defaults, at the venture root (P-2, like next.config.js): the gate (fail-closed routes, rules over the router's path patterns, which package rules it imports), function owners, check settings (P-7, like eslint.config.mjs), thresholds, which System 1 questions run, pinned package versions (U-4) and how strictly the acting role is checked (M-18). Every field is optional; a missing one keeps the default in schema/naive-config.mjs. node schema/check-config.mjs <venture dir> checks it.",
+  "type": "object",
+  "additionalProperties": false,
+  "properties": {
+    "$schema": {
+      "type": "string"
+    },
+    "gate": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "The venture's one gate (X-5). It runs before every write and never calls a model (X-4).",
+      "properties": {
+        "fail_closed": {
+          "type": "array",
+          "description": "Routes whose agent writes are always drafts; each covers that route and every route under it (X-3)",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "rules": {
+          "type": "array",
+          "description": "Rules that read the write itself: who writes it, its route, its confidence (X-1, X-2, X-6)",
+          "items": {
+            "$ref": "#/$defs/rule"
+          }
+        },
+        "packages": {
+          "description": "Which packages' gate rules the gate imports from their package definitions (X-5): true for all (the default), false for none, or a map of package name to false to leave one out",
+          "oneOf": [
+            {
+              "type": "boolean"
+            },
+            {
+              "type": "object",
+              "additionalProperties": {
+                "type": "boolean"
+              }
+            }
+          ]
+        },
+        "variants": {
+          "type": "boolean",
+          "description": "Keep differing agent drafts of one record side by side, with one decision for the founder, on every held route (X-2). A rule can turn this on for its routes alone"
+        }
+      }
+    },
+    "owners": {
+      "type": "object",
+      "description": "Function owners: function (department) id to the role that owns it, so a write routed to its owner reaches the right person (X-2)",
+      "additionalProperties": {
+        "type": "string",
+        "pattern": "^[a-z0-9][a-z0-9-]*$"
+      }
+    },
+    "checks": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Check settings (P-7): which of a route's checks are off, and which only warn",
+      "properties": {
+        "off": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Checks that do not run, by path (schema/check-telos.mjs)"
+        },
+        "warn": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Checks that run but do not fail the route's check"
+        }
+      }
+    },
+    "thresholds": {
+      "type": "object",
+      "description": "Thresholds by name: confidence (the gate's confidence routing), idea-map (when a System 1 answer becomes a tag)",
+      "additionalProperties": {
+        "type": "number",
+        "minimum": 0,
+        "maximum": 1
+      }
+    },
+    "questions": {
+      "type": "object",
+      "description": "Which System 1 questions run, by framework (idea-map): off lists question kinds, the part of a question key before the colon (exists, dept.legal, rec.*)",
+      "additionalProperties": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {
+          "off": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        }
+      }
+    },
+    "packages": {
+      "type": "object",
+      "description": "Pinned package versions (U-4): package name to the version the venture uses. A write to a pinned package whose installed version differs is refused until the pin or the install changes. A pin is a version string, or { version, early, channel } as naive upgrade writes it (U-5)",
+      "additionalProperties": {
+        "oneOf": [
+          {
+            "type": "string",
+            "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+          },
+          {
+            "type": "object",
+            "required": [
+              "version"
+            ],
+            "additionalProperties": false,
+            "properties": {
+              "version": {
+                "type": "string",
+                "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+              },
+              "early": {
+                "type": "boolean"
+              },
+              "channel": {
+                "enum": [
+                  "stable",
+                  "canary"
+                ]
+              }
+            }
+          }
+        ]
+      }
+    },
+    "acting": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "How the acting role is checked on every action (M-18)",
+      "properties": {
+        "unknown_roles": {
+          "enum": [
+            "allow",
+            "refuse"
+          ],
+          "description": "A role id the team plan does not list: allow (the default, it may reach every route) or refuse"
+        }
+      }
+    },
+    "naive": {
+      "type": "object",
+      "description": "The framework version the venture is on, and its channel (EE-076, written by naive upgrade)",
+      "additionalProperties": false,
+      "properties": {
+        "version": {
+          "type": "string",
+          "pattern": "^[0-9]+\\.[0-9]+\\.[0-9]+$"
+        },
+        "channel": {
+          "enum": [
+            "stable",
+            "canary"
+          ]
+        }
+      }
+    },
+    "kits": {
+      "type": "array",
+      "items": {
+        "type": "string"
+      },
+      "description": "Mentura kits whose automations this venture turns on"
+    },
+    "triggers": {
+      "type": "array",
+      "description": "What starts the next step on an event (schema/triggers.mjs)"
+    }
+  },
+  "$defs": {
+    "rule": {
+      "type": "object",
+      "additionalProperties": false,
+      "required": [
+        "id",
+        "routes",
+        "then"
+      ],
+      "properties": {
+        "id": {
+          "type": "string",
+          "pattern": "^[a-z0-9][a-z0-9-]*$"
+        },
+        "routes": {
+          "type": "array",
+          "minItems": 1,
+          "description": "The routes the rule covers, in the router's own path patterns (X-6): a route (validation/pricing), an [id] segment (money/[id]), * for one segment and ** for any depth (validation/**, which covers validation too)",
+          "items": {
+            "type": "string",
+            "minLength": 1
+          }
+        },
+        "actors": {
+          "type": "array",
+          "items": {
+            "enum": [
+              "agent",
+              "person"
+            ]
+          },
+          "description": "Who it applies to; default agents only"
+        },
+        "roles": {
+          "type": "array",
+          "items": {
+            "type": "string"
+          },
+          "description": "Team-plan roles it applies to; default every role"
+        },
+        "when": {
+          "type": "object",
+          "additionalProperties": false,
+          "properties": {
+            "confidence_below": {
+              "description": "Applies when the write carries a confidence score below this number, or below the named threshold. The score is computed before the write; a write with no score never matches",
+              "oneOf": [
+                {
+                  "type": "number",
+                  "minimum": 0,
+                  "maximum": 1
+                },
+                {
+                  "type": "string"
+                }
+              ]
+            },
+            "exists": {
+              "type": "boolean",
+              "description": "Applies only when the record already exists (true) or does not yet (false)"
+            }
+          }
+        },
+        "then": {
+          "enum": [
+            "draft",
+            "owner",
+            "refuse"
+          ],
+          "description": "draft: hold it as a draft; owner: hold it as a draft sent to the function owner; refuse: do not write it"
+        },
+        "owner": {
+          "type": "string",
+          "description": "The owner a routed write goes to; default the function owner in owners, else the record's decision-class owner, else founder"
+        },
+        "variants": {
+          "type": "boolean",
+          "description": "Keep differing drafts side by side under one decision (X-2)"
+        },
+        "note": {
+          "type": "string"
+        }
+      }
+    }
+  }
+}