@intend-it/core 4.0.2 → 4.0.3

package/README.md

@@ -114,29 +114,40 @@ interface AIGeneratorOptions {
 }
 ```
 
-## Caching with CAS
+## 🔒 Build Determinism & Lockfiles
 
-The compiler includes a Content-Addressable Storage system for caching:
+The core package includes a `LockfileManager` that ensures generated code is deterministic and reusable.
 
 ```typescript
-import { FileSystemCAS, computeHash } from "@intend-it/core";
+import { LockfileManager, computeHash } from "@intend-it/core";
 
-const cas = new FileSystemCAS("./.intend/store");
+const lockManager = new LockfileManager("./intend.lock");
 
-// Check cache
-const hash = computeHash(sourceCode, config);
-const cached = await cas.get(hash);
+// Calculate hashes
+const sourceHash = computeHash(intentSource);
+const configHash = computeHash(JSON.stringify(config));
 
-if (cached) {
-  console.log("Cache hit!");
-  return cached.code;
+// Try to get from lockfile
+const cachedCode = lockManager.getEntry(relativePath, sourceHash, configHash);
+
+if (cachedCode) {
+  return cachedCode; // Instant build!
 }
 
-// Generate and cache
+// Generate new code and save to lockfile
 const result = await generator.generate(ast);
-await cas.put(hash, result.code);
+lockManager.setEntry(relativePath, sourceHash, configHash, result.code, {
+  model: "gemini-2.0-flash",
+  provider: "gemini"
+});
+lockManager.save();
 ```
 
+### Why a Lockfile?
+- **Determinism**: Prevents minor AI fluctuations from changing your production code.
+- **Performance**: Skips expensive LLM calls for unchanged intentions.
+- **Auditability**: Changes to generated code appear in your git diffs, making it easy to review what the AI has changed.
+
 ## Architecture
 
 ```

package/dist/index.js

@@ -169308,22 +169308,7 @@ Generate ONLY the TypeScript code for this step (no explanations, no markdown).`
       lines.push("");
     }
     lines.push(`Implementation Steps (in order):`);
-    context.steps.forEach((step, i) => {
-      let line = `${i + 1}. `;
-      if (step.type === "Call") {
-        const args = step.args.map((a) => a.type === "String" ? JSON.stringify(a.value) : a.value).join(", ");
-        line += `Call: ${step.intent}(${args})`;
-      } else {
-        line += `"${step.instruction}"`;
-      }
-      if (step.resultVariable) {
-        line += ` => const ${step.resultVariable}`;
-        if (step.type === "Step" && step.resultType) {
-          line += `: ${step.resultType}`;
-        }
-      }
-      lines.push(line);
-    });
+    lines.push(this.formatSteps(context.steps, 0));
     lines.push("");
     if (context.ensures.length > 0) {
       lines.push(`Postconditions (must be true at the end):`);
@@ -169360,27 +169345,58 @@ Return ONLY the function body code (no function signature, no markdown).`);
     }
     return type;
   }
+  formatSteps(steps, indentLevel) {
+    const indent = "  ".repeat(indentLevel);
+    const lines = [];
+    steps.forEach((step, i) => {
+      let line = `${indent}${i + 1}. `;
+      if (step.type === "Call") {
+        const args = step.args.map((a) => a.type === "String" ? JSON.stringify(a.value) : a.value).join(", ");
+        line += `Call: ${step.intent}(${args})`;
+      } else {
+        line += `"${step.instruction}"`;
+      }
+      if (step.resultVariable) {
+        line += ` => ${step.variableKind || "const"} ${step.resultVariable}`;
+        if (step.type === "Step" && step.resultType) {
+          line += `: ${step.resultType}`;
+        }
+      }
+      lines.push(line);
+      if (step.type === "Step" && step.nestedBody) {
+        lines.push(`${indent}   BLOCK START (This step contains a nested logic block):`);
+        lines.push(this.formatSteps(step.nestedBody.steps, indentLevel + 1));
+        lines.push(`${indent}   BLOCK END`);
+      }
+    });
+    return lines.join(`
+`);
+  }
   buildReviewerSystemPrompt() {
-    return `You are a senior code reviewer specializing in detecting logical errors in TypeScript.
+    return `You are a pragmatic senior code reviewer specializing in ensuring TypeScript code is functionally correct and safe.
+
+Your task is to review generated code for logical errors that would cause runtime failures or violate the business intent.
 
-Your task is to review generated function implementations for subtle bugs that pass syntax validation but are logically incorrect.
+Rules for Approval:
+- BE PRAGMATIC: If the code is functionally correct and will not crash, APPROVE it.
+- DO NOT be pedantic about 'step' names. If a step asks to "Call GenerateID" and the code uses "crypto.randomUUID()", this is CORRECT.
+- DO NOT fail for unused variables (e.g. intermediate variables used in object construction).
+- DO NOT fail for minor stylistic choices or variable shadowing unless it causes a bug.
 
-Common issues to detect:
-1. FUNCTION SHADOWING: An inner function with the same name as the outer function, causing the outer to never be called correctly.
-2. UNUSED VARIABLES: Variables declared but never used or returned.
-3. MISSING STEP IMPLEMENTATION: Steps mentioned in requirements but not implemented.
-4. INFINITE LOOPS / RECURSION: Unintended recursive calls or loops with no exit condition.
-5. TYPE MISMATCHES: Returning wrong type or assigning incompatible types.
-6. DEAD CODE: Code that can never be reached.
+Critical Issues to detect (FAIL only for these):
+1. BUGGY SHADOWING: An inner variable/function with the same name as the outer, causing a reference error or calling the wrong logic.
+2. INFINITE LOOPS: Loops or recursion with no exit condition.
+3. LOGIC GAP: The code completely ignores a requirement (e.g. failing to save a record that was requested).
+4. CRASH POTENTIAL: Accessing properties of 'undefined' without checks, or unhandled 'null' returns.
+5. TYPE CONTRACT VIOLATION: Returning a type that deviates from the signature.
 
 Response Format:
-- If the code is logically correct, respond with exactly: APPROVED
-- If there are issues, respond with:
+- If functionally correct and safe code, respond with exactly: APPROVED
+- If there are CRITICAL ISSUES, respond with:
   ISSUES:
-  - [Issue 1 description]
-  - [Issue 2 description]
+  - [Critical issue description]
   ...
-  FIX: [Brief description of what needs to change]`;
+  FIX: [Short description of required fix]`;
   }
   buildReviewerPrompt(context, code) {
     const lines = [];
@@ -170000,7 +170016,8 @@ ${errorMsg}`);
       \uD83D\uDD0D Logic review found issues for ${functionName} (Attempt ${attempts}/${limit}):`);
         console.log(`      ${logicIssues.issues.slice(0, 3).join(`
       `)}`);
-        console.log(`      Retrying with AI auto-correction...
+        console.log(`
+      Retrying with AI auto-correction...
 `);
         prompt += `
 
@@ -170190,6 +170207,64 @@ function computeHash(content, config) {
   hash.update(JSON.stringify(config));
   return hash.digest("hex");
 }
+// src/lockfile/manager.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2 } from "fs";
+
+class LockfileManager {
+  filePath;
+  lockfile;
+  constructor(filePath) {
+    this.filePath = filePath;
+    this.lockfile = this.load();
+  }
+  load() {
+    if (!existsSync2(this.filePath)) {
+      return {
+        version: "1.0",
+        files: {}
+      };
+    }
+    try {
+      const content = readFileSync2(this.filePath, "utf-8");
+      return JSON.parse(content);
+    } catch (error) {
+      console.warn(`Failed to read lockfile at ${this.filePath}. Starting fresh.`);
+      return {
+        version: "1.0",
+        files: {}
+      };
+    }
+  }
+  save() {
+    try {
+      writeFileSync2(this.filePath, JSON.stringify(this.lockfile, null, 2), "utf-8");
+    } catch (error) {
+      throw new Error(`Failed to write lockfile: ${error.message}`);
+    }
+  }
+  getEntry(relativePath, sourceHash, configHash) {
+    const entry = this.lockfile.files[relativePath];
+    if (!entry)
+      return null;
+    if (entry.sourceHash === sourceHash && entry.configHash === configHash) {
+      return entry.generatedCode;
+    }
+    return null;
+  }
+  setEntry(relativePath, sourceHash, configHash, code, metadata) {
+    this.lockfile.files[relativePath] = {
+      sourceHash,
+      configHash,
+      generatedCode: code,
+      model: metadata?.model,
+      provider: metadata?.provider,
+      timestamp: Date.now()
+    };
+  }
+  getLockfile() {
+    return this.lockfile;
+  }
+}
 export {
   generateTypeScript,
   debugLogger,
@@ -170198,6 +170273,7 @@ export {
   TypeScriptGenerator,
   PromptBuilder,
   OllamaProvider,
+  LockfileManager,
   GeminiProvider,
   GeminiClient,
   FileSystemCAS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intend-it/core",
-  "version": "4.0.2",
+  "version": "4.0.3",
   "description": "Core compiler and AI integration for the Intend programming language",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -35,7 +35,7 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "@intend-it/parser": "^1.3.2",
+    "@intend-it/parser": "^1.3.3",
     "@google/generative-ai": "^0.21.0"
   },
   "devDependencies": {
@@ -43,6 +43,6 @@
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "@intend-it/parser": ">=1.3.2"
+    "@intend-it/parser": ">=1.3.3"
   }
 }