@skillstech/thunderlang 0.1.6

package/src/atlas.mjs

@@ -0,0 +1,118 @@
+// Mission Atlas indexing: aggregate many .intent files into one inventory.
+//
+// This is the deterministic slice of the Atlas. It reports only what is derivable
+// from the .intent files themselves: mission, feature area, a risk heuristic,
+// guarantee/never counts, and DECLARED verification (whether verify tests exist).
+//
+// It deliberately does NOT report test pass counts, proof, or drift. Those need a
+// test runner and OpenThunder (repo evidence), which the compiler does not own.
+// Those columns of the Proof Matrix stay evidence-dependent. See docs/proof-matrix.
+
+import { parseIntent, slug } from './parse.mjs';
+import { sha256 } from './emit.mjs';
+
+// Feature area convention: an explicit `# area: X` comment wins; otherwise the
+// header comment `# <Name>.intent , <Product> / <Area>` is used; else uncategorized.
+function deriveArea(source) {
+  const explicit = source.match(/^#\s*area:\s*(.+)$/im);
+  if (explicit) return explicit[1].trim();
+  const header = source.match(/^#[^\n]*\.intent[^\n]*?\/\s*(.+?)\s*$/im);
+  if (header) return header[1].trim();
+  return null;
+}
+
+const RISK_PATTERNS = {
+  payments: /\b(payment|charge|invoice|checkout|subscription|billing|refund)\b/i,
+  auth: /\b(password|login|auth|session|credential|sign[- ]?in)\b/i,
+  secret: /\b(secret|token)\b/i,
+  pii: /\b(email|pii|personal data|address|phone)\b/i,
+  deployment: /\b(rollback|migration|deploy)\b/i,
+};
+
+// The risk field is a HEURISTIC. To avoid prose noise it scans only structured
+// signal: the mission name, guarantee and never statements, and input names/types.
+function deriveRisk(ast) {
+  const signal = [
+    ast.mission,
+    ...ast.guarantees.map((g) => g.statement),
+    ...ast.neverRules.map((n) => n.statement),
+    ...ast.inputs.map((i) => `${i.name} ${i.type}`),
+  ].filter(Boolean).join(' ');
+
+  const factors = [];
+  for (const [name, re] of Object.entries(RISK_PATTERNS)) if (re.test(signal)) factors.push(name);
+  if (ast.inputs.some((i) => /secret/i.test(i.type)) && !factors.includes('secret')) factors.push('secret');
+
+  const high = factors.includes('payments') || factors.includes('deployment')
+    || (factors.includes('secret') && factors.includes('auth'));
+  const level = high ? 'high'
+    : (factors.includes('secret') || factors.includes('pii') || factors.includes('auth') || factors.length >= 2) ? 'medium'
+    : 'low';
+  return { level, factors };
+}
+
+// DECLARED verification: how many verify tests the mission states, vs how many
+// guarantees + never rules it makes. "declared" is not "passing"; proof needs evidence.
+function deriveVerification(ast) {
+  const rules = ast.guarantees.length + ast.neverRules.length;
+  const verifyTests = ast.verify.length
+    + ast.guarantees.reduce((n, g) => n + (g.verify ? g.verify.length : 0), 0)
+    + ast.neverRules.reduce((n, r) => n + (r.verify ? r.verify.length : 0), 0);
+  let verification = 'none';
+  if (verifyTests > 0) verification = verifyTests >= rules ? 'declared-full' : 'declared-partial';
+  return { verification, verifyTests };
+}
+
+/**
+ * Build a mission index from parsed .intent files.
+ * @param {{path?: string, source: string}[]} files
+ * @param {{product?: string}} [opts]
+ */
+export function buildMissionIndex(files, opts = {}) {
+  const missions = files.map(({ path: p, source }) => {
+    const ast = parseIntent(source);
+    const { verification, verifyTests } = deriveVerification(ast);
+    const { level, factors } = deriveRisk(ast);
+    return {
+      // Stable join keys for downstream consumers (e.g. OpenThunder coverage/drift).
+      // missionId is the compiler's deterministic mission slug; intentProofHash is the
+      // same sha256 the .intent-proof.json carries as sourceHash, so joins need no remap.
+      missionId: ast.mission ? slug(ast.mission) : null,
+      mission: ast.mission || null,
+      intentProofHash: sha256(source),
+      file: p || null,
+      area: deriveArea(source),
+      risk: level,
+      riskFactors: factors,
+      guarantees: ast.guarantees.length,
+      neverRules: ast.neverRules.length,
+      verifyTests,
+      verification,
+      reviewed: ast.approval?.reviewed === true,
+    };
+  }).filter((m) => m.mission);
+
+  missions.sort((a, b) => a.mission.localeCompare(b.mission));
+
+  const byArea = {};
+  for (const m of missions) {
+    const a = m.area || 'uncategorized';
+    byArea[a] = (byArea[a] || 0) + 1;
+  }
+
+  return {
+    schema: 'mission-index-v1',
+    generatedBy: 'intent index',
+    product: opts.product || null,
+    note: 'Verification is DECLARED (verify tests present), not proven. Test pass counts and drift require a test runner and OpenThunder; they are not in this index.',
+    missions,
+    summary: {
+      missions: missions.length,
+      byArea,
+      declaredFull: missions.filter((m) => m.verification === 'declared-full').length,
+      declaredPartial: missions.filter((m) => m.verification === 'declared-partial').length,
+      unverified: missions.filter((m) => m.verification === 'none').length,
+      highRisk: missions.filter((m) => m.risk === 'high').length,
+    },
+  };
+}

package/src/changes.mjs

@@ -0,0 +1,74 @@
+// Change Lens (intent-changes-v1) , what a branch / PR / commit range changed, by MEANING, not
+// lines. Given the before/after graphs of each changed .intent file, it aggregates the semantic
+// diff (reusing diffGraphs), interprets the behavior-level changes (a guarantee/never/invariant
+// added or removed, verification removed, approval invalidated), flags regressions, and returns
+// the set of touched nodes to seed a Focus Graph. Pure (the CLI does the git I/O); browser-safe.
+
+import { diffGraphs } from './semantic-diff.mjs';
+
+export const CHANGES_SCHEMA = 'intent-changes-v1';
+
+const EMPTY = { nodes: [], relationships: [] };
+// The node kinds whose add/remove is a meaningful behavior change worth surfacing.
+const SIGNIFICANT = new Set(['Mission', 'Guarantee', 'Never', 'Invariant', 'Constraint', 'VerificationRule', 'Decision', 'Event', 'Api', 'Outcome', 'OutcomeContract']);
+// Removing one of these is a regression risk (a promise or its proof was taken away).
+const REGRESSION_ON_REMOVE = new Set(['Guarantee', 'Never', 'Invariant', 'VerificationRule']);
+
+const verbFor = (type) => {
+  switch (type) {
+    case 'Guarantee': return 'guarantee';
+    case 'Never': return 'never-rule';
+    case 'Invariant': return 'invariant';
+    case 'VerificationRule': return 'verification';
+    case 'Decision': return 'decision';
+    case 'Event': return 'event';
+    case 'Outcome': case 'OutcomeContract': return 'outcome';
+    default: return type.toLowerCase();
+  }
+};
+
+/**
+ * Build a Change Report from before/after graphs of each changed file.
+ * @param {Array<{path:string, before:object|null, after:object|null}>} pairs
+ */
+export function changeReport(pairs) {
+  const files = [];
+  const highlights = [];
+  const touched = new Set();
+  let added = 0, removed = 0, changed = 0, invalidatedApprovals = 0;
+
+  for (const { path, before, after } of pairs || []) {
+    const d = diffGraphs(before || EMPTY, after || EMPTY);
+    added += d.addedNodes.length; removed += d.removedNodes.length; changed += d.changedNodes.length;
+    invalidatedApprovals += (d.invalidatedApprovals || []).length;
+    const record = (kind, n) => { touched.add(n.id); if (SIGNIFICANT.has(n.type)) highlights.push({ kind, type: n.type, thing: verbFor(n.type), title: n.title, path }); };
+    for (const n of d.addedNodes) record('added', n);
+    for (const n of d.removedNodes) record('removed', n);
+    for (const c of d.changedNodes) {
+      touched.add(c.id);
+      const title = c.after?.title ?? c.before?.title ?? c.id;
+      // A claim losing its verification is a real weakening (a regression), not just a change.
+      const weakened = c.before?.status === 'verify-declared' && c.after?.status === 'unverified';
+      highlights.push({ kind: weakened ? 'weakened' : 'changed', type: c.type, thing: verbFor(c.type), title, path });
+    }
+    files.push({
+      path,
+      status: !before ? 'added' : !after ? 'deleted' : 'modified',
+      added: d.addedNodes.length, removed: d.removedNodes.length, changed: d.changedNodes.length,
+      invalidatedApprovals: (d.invalidatedApprovals || []).length,
+    });
+  }
+
+  const regressions = highlights.filter((h) => h.kind === 'weakened' || (h.kind === 'removed' && REGRESSION_ON_REMOVE.has(h.type)));
+  const semantic = added + removed + changed;
+  return {
+    schema: CHANGES_SCHEMA,
+    totals: { files: files.length, added, removed, changed, invalidatedApprovals, touched: touched.size },
+    // review when a promise/proof was removed or an approval invalidated; else changed/no-op.
+    verdict: (regressions.length || invalidatedApprovals) ? 'review' : (semantic ? 'changed' : 'no-semantic-change'),
+    regressions,
+    highlights,
+    files,
+    touchedNodeIds: [...touched],
+  };
+}

package/src/classification.mjs

@@ -0,0 +1,36 @@
+// Classification + evidence model (intent-graph-v1, Section 5).
+// Every statement carries a classification so AI-generated content never silently
+// becomes observed fact. Pure (no Node deps): browser-safe.
+
+export const CLASSIFICATIONS = [
+  'observed',  // directly supported by a source
+  'inferred',  // derived from evidence, not explicitly stated
+  'proposed',  // a recommendation / possible solution
+  'assumed',   // treated as true, but requires validation
+  'unknown',   // required information, not yet resolved
+  'decided',   // a human-approved choice
+  'verified',  // supported by deterministic verification evidence
+];
+
+// Confidence bands.
+export const CONFIDENCE = ['low', 'medium', 'high'];
+
+/** Classifications that are NOT established fact (must be surfaced with uncertainty). */
+export const UNSETTLED = new Set(['inferred', 'proposed', 'assumed', 'unknown']);
+
+/** Normalize a raw classification word; returns null if unrecognized. */
+export function classify(word) {
+  const w = String(word || '').trim().toLowerCase();
+  return CLASSIFICATIONS.includes(w) ? w : null;
+}
+
+/** True if a statement of this classification may be presented as established fact. */
+export function isFactual(classification) {
+  const c = classify(classification);
+  return c === 'observed' || c === 'decided' || c === 'verified';
+}
+
+/** Phases an unresolved unknown/question can block (Section 7.4). */
+export const BLOCKABLE_PHASES = [
+  'product-approval', 'ux-approval', 'implementation', 'verification', 'release',
+];