@intend-it/core 2.0.7 → 3.0.1

package/dist/index.js

@@ -168837,7 +168837,13 @@ class TypeScriptGenerator {
   }
   generateFunctionSignature(intent) {
     const params = intent.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
-    const returnType = intent.returnType.generic ? `${intent.returnType.base}<${intent.returnType.generic}>` : intent.returnType.base;
+    let returnType = intent.returnType.base;
+    if (intent.returnType.generic) {
+      returnType += `<${intent.returnType.generic}>`;
+    }
+    if (intent.returnType.isArray) {
+      returnType += "[]";
+    }
     const isAsync = returnType.startsWith("Promise");
     const asyncKeyword = isAsync ? "async " : "";
     return `export ${asyncKeyword}function ${intent.name}(${params}): ${returnType} {`;
@@ -168879,6 +168885,26 @@ class TypeScriptGenerator {
           content: `return ${lastStep.resultVariable};`,
           indent: 1
         });
+      } else {
+        const returnBase = intent.returnType.base.toLowerCase();
+        if (returnBase !== "void" && returnBase !== "undefined") {
+          blocks.push({ type: "comment", content: "", indent: 0 });
+          blocks.push({
+            type: "statement",
+            content: `return null as any; // PLACEHOLDER - AI will replace`,
+            indent: 1
+          });
+        }
+      }
+    } else {
+      const returnBase = intent.returnType.base.toLowerCase();
+      if (returnBase !== "void" && returnBase !== "undefined") {
+        blocks.push({ type: "comment", content: "", indent: 0 });
+        blocks.push({
+          type: "statement",
+          content: `return null as any; // PLACEHOLDER - AI will replace`,
+          indent: 1
+        });
       }
     }
     return blocks;
@@ -169110,7 +169136,7 @@ ${request.prompt}`;
 // src/ai/prompt-builder.ts
 class PromptBuilder {
   buildContext(intent, fileImports, importedIntents = []) {
-    const returnType = intent.returnType.generic ? `${intent.returnType.base}<${intent.returnType.generic}>` : intent.returnType.base;
+    const returnType = this.formatReturnType(intent.returnType);
     return {
       functionName: intent.name,
       parameters: intent.parameters,
@@ -169122,25 +169148,6 @@ class PromptBuilder {
       importedIntents
     };
   }
-  buildFullPrompt(context) {
-    let contextStr = "";
-    if (context.importedIntents && context.importedIntents.length > 0) {
-      contextStr += `
-
-IMPORTED DEFINITIONS (Strictly adhere to these contracts):
-`;
-      context.importedIntents.forEach((imp) => {
-        const params = imp.parameters.map((p) => `${p.name}: ${p.type}`).join(", ");
-        contextStr += `- Function ${imp.name}(${params}) -> ${imp.returnType.base}
-`;
-        if (imp.body.invariants.length > 0) {
-          imp.body.invariants.forEach((inv) => contextStr += `    Invariant: ${inv.constraint}
-`);
-        }
-      });
-    }
-    return `...` + contextStr;
-  }
   buildSystemPrompt() {
     return `You are an expert TypeScript developer specializing in clean, production-ready code.
 
@@ -169225,7 +169232,7 @@ Generate ONLY the TypeScript code for this step (no explanations, no markdown).`
       lines.push(`IMPORTED DEFINITIONS (Strictly adhere to these contracts):`);
       context.importedIntents.forEach((imp) => {
         const params = this.formatParameters(imp.parameters);
-        const returnType = imp.returnType.generic ? `${imp.returnType.base}<${imp.returnType.generic}>` : imp.returnType.base;
+        const returnType = this.formatReturnType(imp.returnType);
         lines.push(`- Function ${imp.name}(${params}) -> ${returnType}`);
         if (imp.body.invariants.length > 0) {
           imp.body.invariants.forEach((inv) => lines.push(`    Invariant: ${inv.constraint}`));
@@ -169272,7 +169279,154 @@ Return ONLY the function body code (no function signature, no markdown).`);
       return "none";
     return params.map((p) => `${p.name}: ${p.type}`).join(", ");
   }
+  formatReturnType(rt) {
+    let type = rt.base;
+    if (rt.generic) {
+      type += `<${rt.generic}>`;
+    }
+    if (rt.isArray) {
+      type += "[]";
+    }
+    return type;
+  }
+  buildReviewerSystemPrompt() {
+    return `You are a senior code reviewer specializing in detecting logical errors in TypeScript.
+
+Your task is to review generated function implementations for subtle bugs that pass syntax validation but are logically incorrect.
+
+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.
+
+Response Format:
+- If the code is logically correct, respond with exactly: APPROVED
+- If there are issues, respond with:
+  ISSUES:
+  - [Issue 1 description]
+  - [Issue 2 description]
+  ...
+  FIX: [Brief description of what needs to change]`;
+  }
+  buildReviewerPrompt(context, code) {
+    const lines = [];
+    lines.push(`Review this TypeScript function implementation for logical errors:
+`);
+    lines.push(`Function: ${context.functionName}`);
+    lines.push(`Parameters: ${this.formatParameters(context.parameters)}`);
+    lines.push(`Return Type: ${context.returnType}
+`);
+    lines.push(`Required Steps:`);
+    context.steps.forEach((step, i) => {
+      let line = `${i + 1}. "${step.instruction}"`;
+      if (step.resultVariable) {
+        line += ` => ${step.resultVariable}`;
+        if (step.resultType)
+          line += `: ${step.resultType}`;
+      }
+      lines.push(line);
+    });
+    lines.push(`
+Generated Code:`);
+    lines.push("```typescript");
+    lines.push(code);
+    lines.push("```");
+    lines.push(`
+Verify:`);
+    lines.push(`1. All steps are implemented correctly`);
+    lines.push(`2. No function shadowing or naming conflicts`);
+    lines.push(`3. All declared variables are used`);
+    lines.push(`4. Return value matches required type`);
+    lines.push(`5. No infinite loops or unintended recursion`);
+    lines.push(`
+Respond with APPROVED or ISSUES + FIX as specified.`);
+    return lines.join(`
+`);
+  }
+}
+// src/utils/debug.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  dim: "\x1B[2m",
+  cyan: "\x1B[36m",
+  yellow: "\x1B[33m",
+  magenta: "\x1B[35m",
+  green: "\x1B[32m",
+  blue: "\x1B[34m",
+  gray: "\x1B[90m"
+};
+
+class DebugLogger {
+  enabled;
+  constructor(enabled = false) {
+    this.enabled = enabled;
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  setEnabled(enabled) {
+    this.enabled = enabled;
+  }
+  header(title) {
+    if (!this.enabled)
+      return;
+    console.log();
+    console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+    console.log(`${COLORS.cyan}┃${COLORS.reset} ${COLORS.yellow}\uD83D\uDD0D DEBUG:${COLORS.reset} ${title}`);
+    console.log(`${COLORS.cyan}━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━${COLORS.reset}`);
+  }
+  prompt(label, content) {
+    if (!this.enabled)
+      return;
+    console.log();
+    console.log(`${COLORS.magenta}┌─ ${label} ─────────────────────────────────────────────────────────────────${COLORS.reset}`);
+    this.dimmedBlock(content);
+    console.log(`${COLORS.magenta}└──────────────────────────────────────────────────────────────────────────────${COLORS.reset}`);
+  }
+  thinking(content) {
+    if (!this.enabled || !content)
+      return;
+    console.log();
+    console.log(`${COLORS.blue}┌─ \uD83E\uDDE0 Model Thinking ──────────────────────────────────────────────────────────${COLORS.reset}`);
+    this.dimmedBlock(content);
+    console.log(`${COLORS.blue}└──────────────────────────────────────────────────────────────────────────────${COLORS.reset}`);
+  }
+  response(label, content) {
+    if (!this.enabled)
+      return;
+    console.log();
+    console.log(`${COLORS.green}┌─ ${label} ─────────────────────────────────────────────────────────────────${COLORS.reset}`);
+    this.dimmedBlock(content);
+    console.log(`${COLORS.green}└──────────────────────────────────────────────────────────────────────────────${COLORS.reset}`);
+  }
+  log(message) {
+    if (!this.enabled)
+      return;
+    console.log(`${COLORS.dim}  [debug] ${message}${COLORS.reset}`);
+  }
+  info(key, value) {
+    if (!this.enabled)
+      return;
+    console.log(`${COLORS.dim}  ${key}: ${COLORS.reset}${value}`);
+  }
+  dimmedBlock(content) {
+    const lines = content.split(`
+`);
+    const maxLines = 100;
+    const showLines = lines.slice(0, maxLines);
+    for (const line of showLines) {
+      console.log(`${COLORS.dim}│ ${line}${COLORS.reset}`);
+    }
+    if (lines.length > maxLines) {
+      console.log(`${COLORS.dim}│ ... (${lines.length - maxLines} more lines truncated)${COLORS.reset}`);
+    }
+  }
 }
+var debugLogger = new DebugLogger(false);
+
 // src/ai/providers/gemini.ts
 var DEFAULT_MODEL2 = "gemini-flash-latest";
 var DEFAULT_TEMPERATURE2 = 0.2;
@@ -169296,12 +169450,28 @@ class GeminiProvider {
   }
   async generateCode(request) {
     try {
+      if (request.debug) {
+        debugLogger.setEnabled(true);
+        debugLogger.header(`Gemini API Call (${this.model})`);
+        debugLogger.prompt("System Prompt", request.systemPrompt || "(none)");
+        debugLogger.prompt("User Prompt", request.prompt);
+      }
       const response = await this.makeRequest(request);
+      const code = this.extractCode(response);
+      let thinking;
+      if (request.debug) {
+        const fullText = response?.candidates?.[0]?.content?.parts?.[0]?.text || "";
+        debugLogger.response("Gemini Response", fullText);
+      }
       return {
-        code: this.extractCode(response),
-        success: true
+        code,
+        success: true,
+        thinking
       };
     } catch (error) {
+      if (request.debug) {
+        debugLogger.log(`Error: ${error.message}`);
+      }
       return {
         code: "",
         success: false,
@@ -169407,12 +169577,39 @@ class OllamaProvider {
   }
   async generateCode(request) {
     try {
+      if (request.debug) {
+        debugLogger.setEnabled(true);
+        debugLogger.header(`Ollama API Call (${this.model})`);
+        debugLogger.prompt("System Prompt", request.systemPrompt || "(none)");
+        debugLogger.prompt("User Prompt", request.prompt);
+      }
       const response = await this.makeRequest(request);
+      const code = this.extractCode(response);
+      let thinking;
+      const fullText = response?.response || "";
+      if (response?.thinking) {
+        thinking = response.thinking;
+      } else {
+        const thinkMatch = fullText.match(/<think>([\s\S]*?)<\/think>/);
+        if (thinkMatch) {
+          thinking = thinkMatch[1].trim();
+        }
+      }
+      if (request.debug) {
+        if (thinking) {
+          debugLogger.thinking(thinking);
+        }
+        debugLogger.response("Ollama Response", fullText);
+      }
       return {
-        code: this.extractCode(response),
-        success: true
+        code,
+        success: true,
+        thinking
       };
     } catch (error) {
+      if (request.debug) {
+        debugLogger.log(`Error: ${error.message}`);
+      }
       return {
         code: "",
         success: false,
@@ -169435,6 +169632,7 @@ ${request.prompt}`;
         num_thread: this.num_thread
       }
     };
+    body.think = true;
     try {
       const response = await fetch(url, {
         method: "POST",
@@ -169577,12 +169775,14 @@ class AICodeGenerator {
   validator;
   maxAttempts;
   projectContext;
+  debug;
   constructor(options) {
     this.promptBuilder = new PromptBuilder;
     this.validator = new TypeScriptValidator;
     this.mode = options.mode || "full";
     this.maxAttempts = options.maxAttempts ?? 5;
     this.projectContext = options.projectContext;
+    this.debug = options.debug ?? false;
     const providerName = options.provider || "gemini";
     if (providerName === "ollama") {
       if (!options.ollamaConfig) {
@@ -169650,27 +169850,26 @@ class AICodeGenerator {
     while (attempts < limit) {
       const response = await this.provider.generateCode({
         systemPrompt,
-        prompt
+        prompt,
+        debug: this.debug
       });
       if (!response.success) {
         throw new Error(`AI generation failed: ${response.error}`);
       }
       const cleanCode = this.sanitizeAIResponse(response.code);
       const updatedCode = this.injectImplementation(fileContent, cleanCode, functionName);
-      const errors = this.validator.validate(updatedCode);
-      if (errors.length === 0) {
-        return updatedCode;
-      }
-      attempts++;
-      if (attempts < limit) {
-        const errorMsg = errors.slice(0, 5).map((e) => `Line ${e.line}: ${e.message}`).join(`
+      const syntaxErrors = this.validator.validate(updatedCode);
+      if (syntaxErrors.length > 0) {
+        attempts++;
+        if (attempts < limit) {
+          const errorMsg = syntaxErrors.slice(0, 5).map((e) => `Line ${e.line}: ${e.message}`).join(`
 `);
-        console.log(`   ⚠️  Validation failed for ${functionName} (Attempt ${attempts}/${limit}):`);
-        console.log(errorMsg.split(`
+          console.log(`   ⚠️  Validation failed for ${functionName} (Attempt ${attempts}/${limit}):`);
+          console.log(errorMsg.split(`
 `).map((l) => `      ${l}`).join(`
 `));
-        console.log(`      Retrying with AI auto-correction...`);
-        prompt += `
+          console.log(`      Retrying with AI auto-correction...`);
+          prompt += `
 
 Validation Failed (Attempt ${attempts}/${limit}).
 ` + `The code you generated caused errors:
@@ -169684,10 +169883,42 @@ ${errorMsg}
 ` + `CRITICAL INSTRUCTION: Don't just patch the code. 
 ` + `1. First, analyze WHY this error occurred (e.g., mismatching types, undefined variable).
 ` + `2. Then, generate the completely fixed function body wrapped in a \`\`\`typescript block.
+`;
+        } else {
+          console.warn(`   ❌ Validation failed for ${functionName} after ${limit} attempts.`);
+          await this.explainFailure(functionName, updatedCode, syntaxErrors);
+          return updatedCode;
+        }
+        continue;
+      }
+      const logicIssues = await this.verifyLogic(context, cleanCode);
+      if (logicIssues === null) {
+        return updatedCode;
+      }
+      attempts++;
+      if (attempts < limit) {
+        console.log(`   \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...`);
+        prompt += `
+
+Logic Review Failed (Attempt ${attempts}/${limit}).
+` + `The code you generated has logical issues:
+\`\`\`typescript
+${cleanCode}
+\`\`\`
+
+` + `Issues found:
+${logicIssues.issues.join(`
+`)}
+
+` + `Suggested fix: ${logicIssues.fix}
+
+` + `CRITICAL INSTRUCTION: Fix all logical issues and generate the corrected function body.
 `;
       } else {
-        console.warn(`   ❌ Validation failed for ${functionName} after ${limit} attempts.`);
-        await this.explainFailure(functionName, updatedCode, errors);
+        console.warn(`   ❌ Logic verification failed for ${functionName} after ${limit} attempts.`);
         return updatedCode;
       }
     }
@@ -169698,6 +169929,45 @@ ${errorMsg}
     sanitized = sanitized.replace(/^\s*import\s+.*;?\s*$/gm, "");
     return sanitized.trim();
   }
+  async verifyLogic(context, code) {
+    try {
+      const systemPrompt = this.promptBuilder.buildReviewerSystemPrompt();
+      const prompt = this.promptBuilder.buildReviewerPrompt(context, code);
+      const response = await this.provider.generateCode({
+        systemPrompt,
+        prompt,
+        debug: this.debug
+      });
+      if (!response.success) {
+        console.warn(`   ⚠️  Logic verification skipped (AI error)`);
+        return null;
+      }
+      const reviewResult = response.code.trim();
+      if (reviewResult.toUpperCase().startsWith("APPROVED")) {
+        return null;
+      }
+      const issuesMatch = reviewResult.match(/ISSUES:\s*([\s\S]*?)(?:FIX:|$)/i);
+      const fixMatch = reviewResult.match(/FIX:\s*([\s\S]*?)$/i);
+      if (issuesMatch) {
+        const issueLines = issuesMatch[1].split(`
+`).map((l) => l.trim()).filter((l) => l.startsWith("-") || l.startsWith("*") || l.match(/^\d+\./)).map((l) => l.replace(/^[-*]\s*/, "").replace(/^\d+\.\s*/, ""));
+        const fix = fixMatch ? fixMatch[1].trim() : "Review and fix the issues listed above.";
+        if (issueLines.length > 0) {
+          return { issues: issueLines, fix };
+        }
+      }
+      if (reviewResult.toLowerCase().includes("issue") || reviewResult.toLowerCase().includes("problem")) {
+        return {
+          issues: ["Reviewer found potential issues (see details)"],
+          fix: reviewResult.slice(0, 200)
+        };
+      }
+      return null;
+    } catch (err) {
+      console.warn(`   ⚠️  Logic verification skipped (error)`);
+      return null;
+    }
+  }
   async explainFailure(functionName, code, errors) {
     const errorMsg = errors.map((e) => `Line ${e.line}: ${e.message}`).join(`
 `);
@@ -169717,7 +169987,8 @@ Focus on the root cause. Keep it concise.
       console.log(`   \uD83E\uDD16 Analyzing failure...`);
       const response = await this.provider.generateCode({
         systemPrompt: "You are a helpful coding assistant explaining compile errors.",
-        prompt
+        prompt,
+        debug: this.debug
       });
       if (response.success) {
         console.log(`
@@ -169837,6 +170108,7 @@ function computeHash(content, config) {
 }
 export {
   generateTypeScript,
+  debugLogger,
   computeHash,
   TypeScriptValidator,
   TypeScriptGenerator,
@@ -169845,5 +170117,6 @@ export {
   GeminiProvider,
   GeminiClient,
   FileSystemCAS,
+  DebugLogger,
   AICodeGenerator
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intend-it/core",
-  "version": "2.0.7",
+  "version": "3.0.1",
   "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.1.6",
+    "@intend-it/parser": "^1.2.1",
     "@google/generative-ai": "^0.21.0"
   },
   "devDependencies": {
@@ -43,6 +43,6 @@
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "@intend-it/parser": ">=1.1.6"
+    "@intend-it/parser": ">=1.2.1"
   }
 }