@intend-it/core 3.0.2 → 4.0.1

package/README.md

@@ -2,6 +2,7 @@
   <h1>@intend-it/core</h1>
   <p><strong>AI-Powered Code Generator for the Intend Language</strong></p>
   <p>
+    <a href="https://intend.fly.dev">Documentation</a> •
     <a href="https://www.npmjs.com/package/@intend-it/core"><img src="https://img.shields.io/npm/v/@intend-it/core.svg" alt="npm version"></a>
     <a href="https://www.npmjs.com/package/@intend-it/core"><img src="https://img.shields.io/npm/dm/@intend-it/core.svg" alt="npm downloads"></a>
     <a href="https://github.com/DRFR0ST/intend/blob/main/LICENSE"><img src="https://img.shields.io/npm/l/@intend-it/core.svg" alt="license"></a>
@@ -14,9 +15,12 @@
 
 `@intend-it/core` is the heart of the Intend compiler. It takes parsed AST from `@intend-it/parser` and generates production-ready TypeScript code using AI (Google Gemini or Ollama).
 
+**[Read the full documentation 📖](https://intend.fly.dev)**
+
 ### ✨ Key Features
 
 - **🧠 AI Code Generation** - Transforms natural language steps into actual code
+- **🔀 Hybrid Orchestration** - Mix AI steps with deterministic function calls
 - **🔄 Self-Correction Loop** - Validates output and auto-fixes errors
 - **⚡ Smart Caching (CAS)** - Content-addressable storage for instant rebuilds
 - **🔌 Multi-Provider** - Supports Gemini and Ollama (local)

package/dist/index.js

@@ -168803,8 +168803,15 @@ class TypeScriptGenerator {
 `;
         code += `if (import.meta.main) {
 `;
-        code += `  Promise.resolve(${intent.name}()).catch((err: any) => console.error(err));
+        if (intent.parameters.length === 0) {
+          code += `  Promise.resolve(${intent.name}()).catch((err: any) => console.error(err));
 `;
+        } else {
+          code += `  // CLI Auto-Run disabled: function requires arguments
+`;
+          code += `  // Promise.resolve(${intent.name}(/* ...args */)).catch((err: any) => console.error(err));
+`;
+        }
         code += `}
 `;
       }
@@ -168817,7 +168824,8 @@ class TypeScriptGenerator {
   }
   generateImport(imp) {
     const specifiers = imp.specifiers.join(", ");
-    return `import { ${specifiers} } from "${imp.source}";`;
+    const source = imp.source.replace(/\.intent$/, "");
+    return `import { ${specifiers} } from "${source}";`;
   }
   generateJsDoc(intent) {
     const lines = ["/**"];
@@ -168911,6 +168919,9 @@ class TypeScriptGenerator {
   }
   generateStep(step, index) {
     const blocks = [];
+    if (step.type === "Call") {
+      return this.generateCall(step);
+    }
     if (this.options.includeTodos) {
       blocks.push({
         type: "comment",
@@ -168934,6 +168945,33 @@ class TypeScriptGenerator {
     blocks.push({ type: "comment", content: "", indent: 0 });
     return blocks;
   }
+  generateCall(call) {
+    const blocks = [];
+    const args = call.args.map((arg) => this.generateValue(arg)).join(", ");
+    const callExpr = `await ${call.intent}(${args})`;
+    if (call.resultVariable) {
+      const decl = call.variableKind || "const";
+      blocks.push({
+        type: "statement",
+        content: `${decl} ${call.resultVariable} = ${callExpr};`,
+        indent: 1
+      });
+    } else {
+      blocks.push({
+        type: "statement",
+        content: `${callExpr};`,
+        indent: 1
+      });
+    }
+    blocks.push({ type: "comment", content: "", indent: 0 });
+    return blocks;
+  }
+  generateValue(v) {
+    if (v.type === "String") {
+      return JSON.stringify(v.value);
+    }
+    return v.value;
+  }
   generateEnsure(ensure) {
     const blocks = [];
     const expr = ensure.expression.trim();
@@ -169149,21 +169187,22 @@ class PromptBuilder {
     };
   }
   buildSystemPrompt() {
-    return `You are an expert TypeScript developer specializing in clean, production-ready code.
-
-Your task is to implement function bodies based on natural language specifications.
-
-Rules:
-1. Generate ONLY the implementation code (function body content)
-2. Do NOT include the function signature or braces
-3. Use modern TypeScript syntax and best practices
-4. Handle errors appropriately (throw Error with descriptive messages)
-5. Return values must match the specified return type
-6. Follow the exact steps provided in order
-7. Respect all invariants (add runtime checks if needed)
-8. Ensure all postconditions are satisfied
-9. Use descriptive variable names
-10. Keep code clean and readable`;
+    return `You are an expert Senior TypeScript Developer specializing in robust, production-grade code.
+ 
+ Your task is to implement function bodies based on structured natural language specifications (Intend).
+ 
+ Rules:
+ 1. Generate ONLY the implementation code (function body content).
+ 2. Do NOT include the function signature, exports, or braces surfacing the function.
+ 3. Use strict TypeScript (no 'any' unless absolutely necessary).
+ 4. Handle edge cases and errors defensively (throw descriptive Errors).
+ 5. Return values must strictly match the specified return type.
+ 6. Follow the provided steps EXACTLY in order.
+ 7. Respect all invariants (implement usage checks at the start if needed).
+ 8. Ensure all postconditions (ensures) are satisfiable by your logic.
+ 9. Use clear, semantic variable names.
+ 10. Do not hallucinate imports; use only what is provided.
+ 11. If a variable name in the requirements seems to have a typo (e.g. 'totals' instead of 'total'), fix it to match the defined variable.`;
   }
   buildStepPrompt(context, stepIndex) {
     const step = context.steps[stepIndex];
@@ -169185,7 +169224,12 @@ Rules:
       lines.push("");
     }
     lines.push(`Step ${stepIndex + 1} of ${context.steps.length}:`);
-    lines.push(`"${step.instruction}"`);
+    if (step.type === "Call") {
+      const args = step.args.map((a) => a.type === "String" ? JSON.stringify(a.value) : a.value).join(", ");
+      lines.push(`Execute Call: ${step.intent}(${args})`);
+    } else {
+      lines.push(`"${step.instruction}"`);
+    }
     if (step.resultVariable) {
       lines.push(`
 This step must store its result in a variable named: ${step.resultVariable}`);
@@ -169195,10 +169239,17 @@ This step must store its result in a variable named: ${step.resultVariable}`);
 Previous steps:`);
       for (let i = 0;i < stepIndex; i++) {
         const prevStep = context.steps[i];
+        let desc = "";
+        if (prevStep.type === "Call") {
+          const args = prevStep.args.map((a) => a.type === "String" ? JSON.stringify(a.value) : a.value).join(", ");
+          desc = `Call: ${prevStep.intent}(${args})`;
+        } else {
+          desc = `"${prevStep.instruction}"`;
+        }
         if (prevStep.resultVariable) {
-          lines.push(`- Step ${i + 1}: ${prevStep.instruction} => const ${prevStep.resultVariable}`);
+          lines.push(`- Step ${i + 1}: ${desc} => const ${prevStep.resultVariable}`);
         } else {
-          lines.push(`- Step ${i + 1}: ${prevStep.instruction}`);
+          lines.push(`- Step ${i + 1}: ${desc}`);
         }
       }
     }
@@ -169247,10 +169298,16 @@ Generate ONLY the TypeScript code for this step (no explanations, no markdown).`
     }
     lines.push(`Implementation Steps (in order):`);
     context.steps.forEach((step, i) => {
-      let line = `${i + 1}. "${step.instruction}"`;
+      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.resultType) {
+        if (step.type === "Step" && step.resultType) {
           line += `: ${step.resultType}`;
         }
       }
@@ -169266,6 +169323,9 @@ Generate ONLY the TypeScript code for this step (no explanations, no markdown).`
     lines.push(`The code should:`);
     lines.push(`- Follow all steps in order`);
     lines.push(`- Store results in the specified variable names`);
+    lines.push(`- Make sure that imported functions are called with the correct arguments from the context.`);
+    lines.push(`- Make sure the return value matches the expected return type strictly.`);
+    lines.push(`- If a Step requires a return, ensure it is returned.`);
     lines.push(`- Satisfy all postconditions`);
     lines.push(`- Be production-ready TypeScript`);
     lines.push(`
@@ -169321,10 +169381,16 @@ Response Format:
 `);
     lines.push(`Required Steps:`);
     context.steps.forEach((step, i) => {
-      let line = `${i + 1}. "${step.instruction}"`;
+      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 += ` => ${step.resultVariable}`;
-        if (step.resultType)
+        if (step.type === "Step" && step.resultType)
           line += `: ${step.resultType}`;
       }
       lines.push(line);
@@ -169341,6 +169407,7 @@ Verify:`);
     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(`6. Imports are correct (no .intent extension, only using provided imports)`);
     lines.push(`
 Respond with APPROVED or ISSUES + FIX as specified.`);
     return lines.join(`
@@ -169562,6 +169629,7 @@ ${request.prompt}`;
 var DEFAULT_MODEL3 = "llama3";
 var DEFAULT_BASE_URL = "http://localhost:11434";
 var DEFAULT_TEMPERATURE3 = 0.2;
+var DEFAULT_TIMEOUT = 90 * 60 * 1000;
 
 class OllamaProvider {
   name = "ollama";
@@ -169569,11 +169637,13 @@ class OllamaProvider {
   baseUrl;
   temperature;
   num_thread;
+  timeout;
   constructor(config) {
     this.model = config.model || DEFAULT_MODEL3;
     this.baseUrl = config.baseUrl || DEFAULT_BASE_URL;
     this.temperature = config.temperature ?? DEFAULT_TEMPERATURE3;
     this.num_thread = config.num_thread;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT;
   }
   async generateCode(request) {
     try {
@@ -169633,13 +169703,17 @@ ${request.prompt}`;
       }
     };
     try {
+      const controller = new AbortController;
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
       const response = await fetch(url, {
         method: "POST",
         headers: {
           "Content-Type": "application/json"
         },
-        body: JSON.stringify(body)
+        body: JSON.stringify(body),
+        signal: controller.signal
       });
+      clearTimeout(timeoutId);
       if (!response.ok) {
         throw new Error(`Ollama API error: ${response.status} - ${response.statusText}`);
       }
@@ -169730,7 +169804,10 @@ class TypeScriptValidator {
       esModuleInterop: true,
       skipLibCheck: true,
       checkJs: false,
-      allowJs: false
+      allowJs: false,
+      noImplicitReturns: true,
+      strictNullChecks: true,
+      noImplicitAny: true
     };
     const host = ts.createCompilerHost(compilerOptions);
     const originalReadFile = host.readFile;
@@ -169749,6 +169826,12 @@ class TypeScriptValidator {
 `);
       if (msg.includes("Cannot find global type"))
         return false;
+      if (msg.includes("Cannot find name 'process'"))
+        return false;
+      if (msg.includes("Cannot find name 'console'"))
+        return false;
+      if (msg.includes("Cannot find name 'Buffer'"))
+        return false;
       return true;
     }).map((d) => {
       const line = d.file ? d.file.getLineAndCharacterOfPosition(d.start).line + 1 : 0;
@@ -169778,8 +169861,8 @@ class AICodeGenerator {
   constructor(options) {
     this.promptBuilder = new PromptBuilder;
     this.validator = new TypeScriptValidator;
-    this.mode = options.mode || "full";
-    this.maxAttempts = options.maxAttempts ?? 5;
+    this.mode = "full";
+    this.maxAttempts = options.maxAttempts ?? 3;
     this.projectContext = options.projectContext;
     this.debug = options.debug ?? false;
     const providerName = options.provider || "gemini";
@@ -169828,7 +169911,6 @@ class AICodeGenerator {
       const context = this.promptBuilder.buildContext(intent, file.imports, importedIntents);
       totalSteps += context.steps.length;
       if (this.mode === "step-by-step") {
-        console.warn("Step-by-step mode not fully supported for multi-intent files. Falling back to full generation.");
         currentCode = await this.generateFull(currentCode, context, intent.name);
       } else {
         currentCode = await this.generateFull(currentCode, context, intent.name);
@@ -169856,18 +169938,21 @@ class AICodeGenerator {
         throw new Error(`AI generation failed: ${response.error}`);
       }
       const cleanCode = this.sanitizeAIResponse(response.code);
-      const updatedCode = this.injectImplementation(fileContent, cleanCode, functionName);
-      const syntaxErrors = this.validator.validate(updatedCode);
+      const { code: updatedCode, startLine, endLine } = this.injectImplementation(fileContent, functionName, cleanCode);
+      let syntaxErrors = this.validator.validate(updatedCode);
+      syntaxErrors = syntaxErrors.filter((e) => e.line >= startLine + 1 && e.line <= endLine + 1);
       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(`
+      ⚠️  Validation failed for ${functionName} (Attempt ${attempts}/${limit}):`);
           console.log(errorMsg.split(`
 `).map((l) => `      ${l}`).join(`
 `));
-          console.log(`      Retrying with AI auto-correction...`);
+          console.log(`      Retrying with AI auto-correction...
+`);
           prompt += `
 
 Validation Failed (Attempt ${attempts}/${limit}).
@@ -169879,14 +169964,17 @@ ${cleanCode}
 ` + `Errors encountered:
 ${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.
+` + `CRITICAL: You are fixing a critical syntax/compilation error.
+` + `1. ANALYZE: Briefly explain why the error happened.
+` + `2. FIX: Generate the COMPLETE, FIXED function body wrapped in \`\`\`typescript.
+` + `Do not return partial snippets. Return the full function body.
 `;
         } else {
-          console.warn(`   ❌ Validation failed for ${functionName} after ${limit} attempts.`);
-          await this.explainFailure(functionName, updatedCode, syntaxErrors);
-          return updatedCode;
+          const errorMsg = syntaxErrors.slice(0, 5).map((e) => `Line ${e.line}: ${e.message}`).join(`
+`);
+          throw new Error(`Validation failed for ${functionName} after ${limit} attempts.
+Errors:
+${errorMsg}`);
         }
         continue;
       }
@@ -169896,10 +169984,12 @@ ${errorMsg}
       }
       attempts++;
       if (attempts < limit) {
-        console.log(`   \uD83D\uDD0D Logic review found issues for ${functionName} (Attempt ${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...`);
+        console.log(`      Retrying with AI auto-correction...
+`);
         prompt += `
 
 Logic Review Failed (Attempt ${attempts}/${limit}).
@@ -169914,17 +170004,23 @@ ${logicIssues.issues.join(`
 
 ` + `Suggested fix: ${logicIssues.fix}
 
-` + `CRITICAL INSTRUCTION: Fix all logical issues and generate the corrected function body.
+` + `CRITICAL: You are fixing a LOGICAL issue.
+` + `1. ANALYZE: Briefly explain the logic flaw.
+` + `2. FIX: Generate the COMPLETE, FIXED function body wrapped in \`\`\`typescript.
+` + `Ensure every step from the requirements is fully implemented.
 `;
       } else {
-        console.warn(`   ❌ Logic verification failed for ${functionName} after ${limit} attempts.`);
-        return updatedCode;
+        throw new Error(`Logic verification failed for ${functionName} after ${limit} attempts.
+Issues:
+${logicIssues.issues.join(`
+`)}`);
       }
     }
     return fileContent;
   }
   sanitizeAIResponse(code) {
     let sanitized = code.replace(/```typescript\s*/g, "").replace(/```\s*/g, "");
+    sanitized = sanitized.replace(/^(Here is|Sure|I have|Certainly).+$/gim, "");
     sanitized = sanitized.replace(/^\s*import\s+.*;?\s*$/gm, "");
     return sanitized.trim();
   }
@@ -169968,40 +170064,9 @@ ${logicIssues.issues.join(`
     }
   }
   async explainFailure(functionName, code, errors) {
-    const errorMsg = errors.map((e) => `Line ${e.line}: ${e.message}`).join(`
-`);
-    const prompt = `
-The following TypeScript implementation for '${functionName}' failed validation after multiple self-correction attempts.
-
-Code:
-${code}
-
-Errors:
-${errorMsg}
-
-Please explain to the user why this code is failing and what they might need to fix in their .intend file or configuration.
-Focus on the root cause. Keep it concise.
-`;
-    try {
-      console.log(`   \uD83E\uDD16 Analyzing failure...`);
-      const response = await this.provider.generateCode({
-        systemPrompt: "You are a helpful coding assistant explaining compile errors.",
-        prompt,
-        debug: this.debug
-      });
-      if (response.success) {
-        console.log(`
-==================================================`);
-        console.log("\uD83E\uDD16 AI DIAGNOSTICS:");
-        console.log(response.code);
-        console.log(`==================================================
-`);
-      }
-    } catch (err) {
-      console.warn("Failed to generate diagnostics.");
-    }
+    return;
   }
-  injectImplementation(fileContent, implementation, functionName) {
+  injectImplementation(fileContent, functionName, implementation) {
     const lines = fileContent.split(`
 `);
     let startLine = -1;
@@ -170029,8 +170094,12 @@ Focus on the root cause. Keep it concise.
       }
     }
     if (!foundStart || endLine === -1) {
-      console.error(`Could not find function body for ${functionName}. Regex: ${regex}`);
-      return fileContent;
+      throw new Error(`Fatal: Could not filter function body for injection.
+Function: ${functionName}
+Regex: ${regex}
+Start found: ${foundStart}, End found: ${endLine !== -1}
+
+Possible cause: Formatting mismatch between template and injector.`);
     }
     const pre = lines.slice(0, startLine + 1).join(`
 `);
@@ -170043,9 +170112,13 @@ Focus on the root cause. Keep it concise.
       return "";
     }).join(`
 `);
-    return pre + `
-` + indentedImpl + `
-` + post;
+    return {
+      code: `${pre}
+${indentedImpl}
+${post}`,
+      startLine: startLine + 1,
+      endLine: endLine + 1
+    };
   }
   async testConnection() {
     return await this.provider.testConnection();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@intend-it/core",
-  "version": "3.0.2",
+  "version": "4.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.2.2",
+    "@intend-it/parser": "^1.3.1",
     "@google/generative-ai": "^0.21.0"
   },
   "devDependencies": {
@@ -43,6 +43,6 @@
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "@intend-it/parser": ">=1.2.2"
+    "@intend-it/parser": ">=1.3.1"
   }
 }