@skillstech/thunderlang 0.1.6 → 0.1.7

package/src/codegen.mjs

@@ -2,7 +2,7 @@
 // intent always produces the same code. It generates what the intent fully determines (typed
 // interfaces, and the decision logic, which is already executable) and leaves honest TODO
 // markers where a human must supply the business logic , never a fake implementation. This is
-// the "see how it works, then change it" surface for the playground and `intent gen`.
+// the "see how it works, then change it" surface for the playground and `thunder gen`.
 //
 // Pure and browser-safe so the playground can render it. TypeScript first; the same adapter
 // shape (a type map + a body walk) extends to C# / Java.

package/src/compile.mjs

@@ -30,7 +30,7 @@ export function renderMarkdown(ast) {
 
 /**
  * Render a mission as Markdown documentation for ONE audience, weaving that lens's
- * IntentLens notes inline next to the mission element they annotate. Notes explain
+ * ThunderLens notes inline next to the mission element they annotate. Notes explain
  * meaning; they are never verification, and the doc says so. Pure and browser-safe.
  */
 export function renderLensDoc(ast, lens) {
@@ -40,7 +40,7 @@ export function renderLensDoc(ast, lens) {
   const notesFor = (path) => (ast.notes || []).filter((n) => n.lens === lens && n.targetPath === path);
   const L = [];
   L.push(`# ${m} , for the ${lens} reader`, '');
-  L.push(`> IntentLens \`${lens}\` notes are woven in below. They explain meaning for this`,
+  L.push(`> ThunderLens \`${lens}\` notes are woven in below. They explain meaning for this`,
     `> audience; they are documentation, not verification.`, '');
   for (const nt of notesFor(prefix)) L.push(`_${flat(nt.text)}_`, '');
   if (ast.goal) L.push(`**Goal.** ${ast.goal}`, '');
@@ -93,7 +93,7 @@ export function renderTestplan(ast) {
 }
 
 /**
- * Compile ThunderLang source in memory and return every artifact `intent build`
+ * Compile ThunderLang source in memory and return every artifact `thunder build`
  * would emit, without touching the filesystem.
  */
 export function compileSource(source, { sourceFile = 'playground.intent', generatedAt, origin = 'authored' } = {}) {

package/src/drift.mjs

@@ -2,7 +2,7 @@
 // still matches the approved intent. Deterministic, no AI. This is the
 // compiler-side drift check; OpenThunder does the deeper repo-wide version later.
 //
-//   lift code -> .intent draft -> intent approve -> (code changes) -> intent drift
+//   lift code -> .intent draft -> thunder approve -> (code changes) -> intent drift
 
 import { createHash } from 'node:crypto';
 import { parseIntent, slug } from './parse.mjs';
@@ -45,7 +45,7 @@ export function approveIntent(intentText, { approvedBy, approvedAt } = {}) {
     .replace(/^(\s*)reviewed\s+false\b/m, '$1reviewed true')
     .replace(/\s+$/, '');
   // Hash the exact content that gets written (post reviewed-flip), so a later
-  // `intent drift` recomputes the same hash when nothing has changed.
+  // `thunder drift` recomputes the same hash when nothing has changed.
   const hash = sha256(base.trim());
   const lines = ['approval', '  reviewed true'];
   if (approvedBy) lines.push(`  approved_by ${approvedBy}`);
@@ -137,7 +137,7 @@ export function checkDrift(intentText, codeSource, { language = 'typescript' } =
       add('warning', 'INTENT_DRIFT_STALE_PROOF', 'The approved intent was edited after approval (hash mismatch). Re-approve it.');
     }
   } else {
-    add('info', 'INTENT_DRIFT_NOT_APPROVED', 'This intent has no approval block. Approve it first: intent approve <file>.');
+    add('info', 'INTENT_DRIFT_NOT_APPROVED', 'This intent has no approval block. Approve it first: thunder approve <file>.');
   }
 
   const lift = liftSource(codeSource, { language });

package/src/emit.mjs

@@ -188,7 +188,7 @@ export function semanticDiagnostics(ast) {
     }
   }
 
-  // ── IntentLens note checks (understanding, never verification) ──
+  // ── ThunderLens note checks (understanding, never verification) ──
   for (const note of ast.notes || []) {
     if (!KNOWN_LENSES.includes(note.lens)) {
       warn('INTENT_NOTE_UNKNOWN_LENS',
@@ -245,7 +245,7 @@ export function semanticDiagnostics(ast) {
   }
 
   // ── Product / intent-graph diagnostics (intent-graph-v1) ──
-  // Role-aware. Kept at warning/info so `intent check` stays valid; `severity` +
+  // Role-aware. Kept at warning/info so `thunder check` stays valid; `severity` +
   // `blocks` drive phase gates (a valid spec can still be not-ready-to-proceed).
   for (const m of ast.metrics || []) {
     if (!m.window) d.push({

package/src/focus.mjs

@@ -33,7 +33,7 @@ function fingerprint(parts) {
 
 /** Build a typed Intent Scope. `createdAt` is supplied by the caller (deterministic/testable). */
 export function makeScope({ type = 'custom', title = null, seeds = [], projectId = null, createdBy = null, createdAt = null, ...rest } = {}) {
-  if (!SCOPE_TYPES.includes(type)) throw new Error(`intent focus: unknown scope type "${type}"`);
+  if (!SCOPE_TYPES.includes(type)) throw new Error(`thunder focus: unknown scope type "${type}"`);
   return {
     schema: FOCUS_SCHEMA,
     scopeId: `scope.${type}.${fingerprint([type, ...seeds].map(String))}`,

package/src/guard.mjs

@@ -65,7 +65,7 @@ export function buildGuard(ast, { denyResults, mask = '[redacted]' } = {}) {
 
   function decide(name, inputs) {
     const d = decisions.get(name);
-    if (!d) throw new Error(`intent guard: no decision "${name}"`);
+    if (!d) throw new Error(`thunder guard: no decision "${name}"`);
     const r = evaluateDecision(d, inputs || {});
     return { ...r, allowed: !isDenied(r.result) };
   }
@@ -73,7 +73,7 @@ export function buildGuard(ast, { denyResults, mask = '[redacted]' } = {}) {
   function assertAllowed(name, inputs) {
     const r = decide(name, inputs);
     if (!r.allowed) {
-      const e = new Error(`intent guard: decision "${name}" denied the action (result: ${r.result})`);
+      const e = new Error(`thunder guard: decision "${name}" denied the action (result: ${r.result})`);
       e.code = 'INTENT_GUARD_DENIED';
       e.decision = name;
       e.result = r.result;
@@ -98,7 +98,7 @@ export function compileGuard(intentText, opts) {
   return buildGuard(parseIntent(String(intentText ?? '')), opts);
 }
 
-/** A JSON-able summary of what a guard would enforce (for `intent guard` / audits). */
+/** A JSON-able summary of what a guard would enforce (for `thunder guard` / audits). */
 export function guardSummary(ast) {
   const g = buildGuard(ast);
   return { schema: GUARD_SCHEMA, redactsFields: g.secretFields, enforcesDecisions: g.decisions, neverRules: g.neverRules };

package/src/intellisense.mjs

@@ -129,7 +129,7 @@ export function getHover(source, position = {}) {
     return {
       hover: {
         target: lens, kind: 'note_lens', title: `note ${lens}`,
-        description: LENS_INFO[lens] || 'An IntentLens reader lens.',
+        description: LENS_INFO[lens] || 'An ThunderLens reader lens.',
         examples: [], relatedSuggestions: [],
       },
     };

package/src/intent-schema.mjs

@@ -3,7 +3,7 @@
 // enums / diagnostics (gap-closure program non-negotiable #1). Pure (no Node deps).
 //
 // IL owns + versions this. OT/RM/ST/STW import these enums + the JSON Schema instead
-// of maintaining their own copies. `intent schema` emits the JSON Schema.
+// of maintaining their own copies. `thunder schema` emits the JSON Schema.
 
 import { CLASSIFICATIONS, CONFIDENCE } from './classification.mjs';
 
@@ -134,7 +134,7 @@ const IL_AUTHOR_RULE_ROWS = [
   { ruleId: 'IL-SEC-002', area: 'security', severity: 'blocker', blocks: ['release'], summary: 'API returns a secret with no auth requirement.' },
   { ruleId: 'IL-TYPE-001', area: 'type', severity: 'info', blocks: [], summary: 'Field uses an unrecognized (likely mistyped) type.' },
   // 12-Factor Agents conformance (twelve-factor-v1). Advisory: an intent's alignment with the
-  // humanlayer/12-factor-agents principles. `intent twelve-factor` scores these.
+  // humanlayer/12-factor-agents principles. `thunder twelve-factor` scores these.
   { ruleId: 'IL-12F-01', area: 'twelve-factor', severity: 'info', blocks: [], summary: 'F1 Natural language to tool calls: model dispatch as a decision/command.' },
   { ruleId: 'IL-12F-02', area: 'twelve-factor', severity: 'info', blocks: [], summary: 'F2 Own your prompts: behavior is an owned, guaranteed contract, not a black box.' },
   { ruleId: 'IL-12F-03', area: 'twelve-factor', severity: 'info', blocks: [], summary: 'F3 Own your context window: declare a scope boundary.' },
@@ -165,8 +165,8 @@ const IL_CORE_RULE_ROWS = [
   { ruleId: 'unknown-block', area: 'core', severity: 'info', blocks: [], summary: 'Unrecognized top-level block.' },
   { ruleId: 'INTENT-ARCH-001', area: 'architecture', severity: 'warning', blocks: [], summary: 'Architecture rule not understood.' },
   { ruleId: 'INTENT-AI-010', area: 'ai', severity: 'warning', blocks: [], summary: 'Unsupported implementation scope.' },
-  { ruleId: 'INTENT_NOTE_UNKNOWN_LENS', area: 'note', severity: 'info', blocks: [], summary: 'IntentLens note uses an unknown lens.' },
-  { ruleId: 'INTENT_NOTE_EMPTY', area: 'note', severity: 'info', blocks: [], summary: 'IntentLens note is empty.' },
+  { ruleId: 'INTENT_NOTE_UNKNOWN_LENS', area: 'note', severity: 'info', blocks: [], summary: 'ThunderLens note uses an unknown lens.' },
+  { ruleId: 'INTENT_NOTE_EMPTY', area: 'note', severity: 'info', blocks: [], summary: 'ThunderLens note is empty.' },
 ];
 
 // ── Rule namespaces: ONE id space across two PHASES ──────────────────────────

package/src/ledger.mjs

@@ -40,7 +40,7 @@ function payloadOf(seq, entry, prev) {
 
 /** Append an entry to the ledger, hash-chained over the previous head. Returns a NEW ledger. */
 export function record(ledger, entry) {
-  if (!entry || !ENTRY_TYPES.includes(entry.type)) throw new Error(`intent ledger: unknown entry type "${entry?.type}"`);
+  if (!entry || !ENTRY_TYPES.includes(entry.type)) throw new Error(`thunder ledger: unknown entry type "${entry?.type}"`);
   const base = ledger && Array.isArray(ledger.entries) ? ledger : emptyLedger();
   const payload = payloadOf(base.entries.length, entry, base.head);
   const hash = sha256(JSON.stringify(payload));

package/src/lift.mjs

@@ -546,7 +546,7 @@ function liftDiagnostics(lift, facts) {
  * Lift a set of source files (a repo) into inferred ThunderLang drafts, one per
  * file that yields a mission. `files` is [{ file, source }] (the CLI reads the
  * filesystem; this core function stays pure). Returns per-mission drafts + a
- * repo-level summary matching the `intent lift --from repo --json` contract.
+ * repo-level summary matching the `thunder lift --from repo --json` contract.
  */
 export function languageForFile(file) {
   if (/\.rs$/i.test(file)) return 'rust';
@@ -651,7 +651,7 @@ const LANG_EXT = {
  * EXACT node ids instead of lift's own function refs, so there is no divergent second reading.
  * Additive: with no seeds the output is byte-identical to before.
  */
-export function liftSource(source, { language = 'typescript', file = '', seeds } = {}) {
+export function liftSource(source, { language = 'typescript', file = '', seeds = undefined } = {}) {
   const key = String(language).toLowerCase();
   const adapter = ADAPTERS[key];
   if (!adapter) {

package/src/lsp.mjs

@@ -1,7 +1,7 @@
 // A minimal Language Server for ThunderLang (LSP over stdio). Wraps the compiler's existing
 // diagnostics + IntelliSense so ANY LSP-capable editor (VS Code, Neovim, Helix, ...) gets
 // live ThunderLang intelligence: diagnostics on open/change, keyword/type completions, and
-// hover docs for semantic types and note lenses. Deterministic; no AI. `intent lsp` starts it.
+// hover docs for semantic types and note lenses. Deterministic; no AI. `thunder lsp` starts it.
 
 import { parseIntent } from './parse.mjs';
 import { semanticDiagnostics } from './emit.mjs';

package/src/mcp.mjs

@@ -4,7 +4,7 @@
 // check its own output, and , the keystone , verify a proposed code change against the intent
 // before it ships. No AI runs here; every tool is the pure, deterministic compiler.
 //
-// Start it with `intent mcp`. Point an MCP client at that command.
+// Start it with `thunder mcp`. Point an MCP client at that command.
 
 import { parseIntent } from './parse.mjs';
 import { semanticDiagnostics, COMPILER_VERSION } from './emit.mjs';

package/src/parse.mjs

@@ -86,7 +86,7 @@ function buildTree(rows) {
   return root.children;
 }
 
-// Known IntentLens reader lenses. Unknown lenses warn (INTENT_NOTE_UNKNOWN_LENS).
+// Known ThunderLens reader lenses. Unknown lenses warn (INTENT_NOTE_UNKNOWN_LENS).
 export const KNOWN_LENSES = [
   'pm', 'beginner', 'qa', 'risk', 'security', 'support', 'reviewer', 'ops', 'non_goal', 'term',
 ];
@@ -114,7 +114,7 @@ const kvChildren = (node) => {
 const childBlock = (node, kw) => node.children.find((c) => firstWord(c.text) === kw);
 
 function parseFields(node) {
-  // "key: Type" lines. A field may carry indented modifiers and IntentLens notes.
+  // "key: Type" lines. A field may carry indented modifiers and ThunderLens notes.
   return node.children.map((c) => {
     const m = c.text.match(/^([A-Za-z_][\w]*)\s*:\s*(.+)$/);
     const modifiers = [];
@@ -712,7 +712,7 @@ export function parseIntent(source) {
     }
   }
 
-  // ── Assemble IntentLens notes with stable ids, target kinds, paths, spans ──
+  // ── Assemble ThunderLens notes with stable ids, target kinds, paths, spans ──
   const mprefix = `mission.${ast.mission || 'unnamed'}`;
   const pushNote = (raw, targetKind, targetPath) => {
     if (!raw) return;

package/src/proof-schema.mjs

@@ -1,5 +1,5 @@
 // Canonical proof envelope schema (intent-proof-v1) , the shape of a `.intent-proof.json`
-// document. IL owns this: it is what the compiler emits (`buildProof`), what `intent verify`
+// document. IL owns this: it is what the compiler emits (`buildProof`), what `thunder verify`
 // re-derives against, and the "shared envelope" siblings sign (STW) and re-verify (RM/OT)
 // rather than each re-describing the proof shape. Pure ESM, ZERO Node deps , browser-safe so
 // a signing service or a cert renderer can validate an envelope without a Node build.
@@ -41,7 +41,7 @@ export function intentProofJsonSchema() {
       sourceProduct: { type: 'string' },
       missionName: { type: ['string', 'null'] },
       sourceFile: { type: 'string' },
-      // sha256:<hex> , the source fingerprint `intent verify` re-checks for drift/tampering.
+      // sha256:<hex> , the source fingerprint `thunder verify` re-checks for drift/tampering.
       sourceHash: { type: 'string', pattern: '^sha256:[0-9a-f]{64}$' },
       compilerVersion: { type: 'string' },
       generatedAt: { type: ['string', 'null'] },

package/src/report.mjs

@@ -1,4 +1,4 @@
-// Repo-wide intent health report (intent-report-v1). `intent check` gates a build pass/fail;
+// Repo-wide intent health report (intent-report-v1). `thunder check` gates a build pass/fail;
 // this AGGREGATES across every .intent file into a triage view a team adopting ThunderLang can
 // act on: how many missions, diagnostics by severity + area, the most common codes, and
 // coverage signals (are guarantees verified? do missions have tests? are outcomes contracted?).

package/src/sarif.mjs

@@ -1,4 +1,4 @@
-// SARIF 2.1.0 output for `intent check` , so ThunderLang diagnostics show up natively in the
+// SARIF 2.1.0 output for `thunder check` , so ThunderLang diagnostics show up natively in the
 // surfaces teams already use: GitHub / GitLab code scanning (inline PR annotations + the
 // Security tab) and any SARIF-aware IDE. Pure: reports in, one SARIF log object out.
 //

package/src/scan-queries.mjs

@@ -1,5 +1,5 @@
 // Scanner query views (intent-scan-view-v1) , the deterministic answers behind the Part 3
-// CLI verbs: `intent risks | gaps | unverified | coverage | unknowns | contradictions`.
+// CLI verbs: `thunder risks | gaps | unverified | coverage | unknowns | contradictions`.
 // These are pure derivations over a scanProject() result (its Intent IR + Fable findings) ,
 // no new analysis, no AI. They exist so a person can ask one focused question ("what is
 // unverified?", "what contradicts?") instead of reading the whole scan report.

package/src/style.mjs

@@ -85,7 +85,7 @@ function setPath(root, path, leaf) {
 /**
  * Deterministic diagnostics for every `style_intent` block. Returns an array of
  * { ruleId, severity, blocks, message, styleIntent, line } , the same shape the rest of
- * the compiler emits, so it composes into `intent check` with no special-casing.
+ * the compiler emits, so it composes into `thunder check` with no special-casing.
  */
 export function styleDiagnostics(ast) {
   const out = [];
@@ -199,7 +199,7 @@ export function toDesignTokens(ast) {
     });
     for (const t of si.tokens) {
       const leaf = { $value: coerceValue(t.value), $type: tokenType(t.path) };
-      if (!isKnownPath(t.path)) leaf.$extensions = { 'dev.thunderlang': { canonical: false } };
+      if (!isKnownPath(t.path)) leaf.$extensions = { 'dev.intentlanguage': { canonical: false } };
       setPath(root, t.path, leaf);
     }
   }
@@ -207,7 +207,7 @@ export function toDesignTokens(ast) {
     $description: `Design tokens for ${ast.title || ast.mission || 'intent'} (generated from style_intent by @skillstech/thunderlang)`,
     ...root,
     $extensions: {
-      'dev.thunderlang': {
+      'dev.intentlanguage': {
         schema: DESIGN_TOKENS_SCHEMA,
         format: 'W3C Design Tokens (DTCG)',
         source: ast.mission || null,

package/src/twelve-factor.mjs

@@ -9,7 +9,7 @@
 //
 // Verdicts: 'satisfied' | 'partial' | 'absent'. Score = (satisfied + 0.5*partial) / 13.
 // Each factor cites the IL signal it inspects, the evidence found, and a concrete fix. The
-// finding ids (IL-12F-01..13) are in the canonical rule catalog for `intent explain`.
+// finding ids (IL-12F-01..13) are in the canonical rule catalog for `thunder explain`.
 
 export const TWELVE_FACTOR_SCHEMA = 'twelve-factor-v1';
 
@@ -44,7 +44,7 @@ const FACTORS = [
       const scoped = len(ast.scope?.include) + len(ast.scope?.exclude);
       if (scoped) return { verdict: 'satisfied', evidence: `context boundary declared (scope: ${len(ast.scope.include)} include / ${len(ast.scope.exclude)} exclude)` };
       if (len(ast.requires)) return { verdict: 'partial', evidence: 'dependencies declared but no explicit scope boundary', fix: 'Declare `scope include/exclude` so the context window is curated, not unbounded.' };
-      return { verdict: 'absent', evidence: 'no scope declared', fix: 'Add a `scope` block to bound what belongs in context (IntentLens/Focus narrows it further).' };
+      return { verdict: 'absent', evidence: 'no scope declared', fix: 'Add a `scope` block to bound what belongs in context (ThunderLens/Focus narrows it further).' };
     },
   },
   {