@contextos/core 0.2.3 → 0.3.0

package/dist/index.js

@@ -1963,7 +1963,7 @@ var RateLimiter = class {
   async waitForSlot() {
     const result = await this.checkLimit();
     if (!result.allowed) {
-      await new Promise((resolve2) => setTimeout(resolve2, result.waitTime + 100));
+      await new Promise((resolve3) => setTimeout(resolve3, result.waitTime + 100));
       return this.waitForSlot();
     }
   }
@@ -2091,7 +2091,7 @@ var GeminiClient = class {
       const waitTime = retryAfter ? parseInt(retryAfter) * 1e3 : 6e4;
       if (retryCount < 3) {
         console.warn(`Rate limited. Waiting ${waitTime}ms before retry (${retryCount + 1}/3)...`);
-        await new Promise((resolve2) => setTimeout(resolve2, waitTime));
+        await new Promise((resolve3) => setTimeout(resolve3, waitTime));
         return this.request(prompt, systemPrompt, retryCount + 1);
       }
       throw new Error(`Rate limit exceeded after ${retryCount} retries. Please try again later.`);
@@ -2275,6 +2275,18 @@ Output the compressed version directly.`;
       tokensSaved: originalTokens - newTokens
     };
   }
+  /**
+   * Generate code or content from a prompt
+   * Used by AIGenerator for code generation
+   */
+  async generate(prompt) {
+    const response = await this.request(prompt);
+    return {
+      text: response,
+      tokensUsed: Math.ceil(response.length / 4)
+      // Rough estimate
+    };
+  }
 };
 function createGeminiClient() {
   const apiKey = process.env.GEMINI_API_KEY;
@@ -3066,7 +3078,7 @@ var OpenAIAdapter = class {
         const waitTime = retryAfter ? parseInt(retryAfter) * 1e3 : 6e4;
         if (retryCount < 3) {
           console.warn(`OpenAI rate limited. Waiting ${waitTime}ms before retry (${retryCount + 1}/3)...`);
-          await new Promise((resolve2) => setTimeout(resolve2, waitTime));
+          await new Promise((resolve3) => setTimeout(resolve3, waitTime));
           return this.complete(request, retryCount + 1);
         }
         return {
@@ -3166,7 +3178,7 @@ var AnthropicAdapter = class {
         const waitTime = retryAfter ? parseInt(retryAfter) * 1e3 : 6e4;
         if (retryCount < 3) {
           console.warn(`Anthropic rate limited. Waiting ${waitTime}ms before retry (${retryCount + 1}/3)...`);
-          await new Promise((resolve2) => setTimeout(resolve2, waitTime));
+          await new Promise((resolve3) => setTimeout(resolve3, waitTime));
           return this.complete(request, retryCount + 1);
         }
         return {
@@ -7578,7 +7590,234 @@ function createLogger(config) {
 function setGlobalLogger(logger) {
   globalLogger = logger;
 }
+
+// src/generator/index.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync13 } from "fs";
+import { dirname as dirname4, join as join13, resolve as resolve2, normalize as normalize3 } from "path";
+var AIGenerator = class {
+  config = null;
+  gemini = null;
+  openai = null;
+  rootDir = process.cwd();
+  constructor(projectDir) {
+    this.rootDir = projectDir || process.cwd();
+  }
+  /**
+   * Initialize the generator
+   */
+  async initialize() {
+    try {
+      this.config = loadConfig(this.rootDir);
+      this.rootDir = this.config.rootDir;
+    } catch {
+    }
+    if (isGeminiAvailable()) {
+      this.gemini = createGeminiClient();
+    }
+    if (isOpenAIAvailable()) {
+      this.openai = createOpenAIAdapter();
+    }
+    if (!this.gemini && !this.openai) {
+      throw new Error("No AI API key found. Set GEMINI_API_KEY or OPENAI_API_KEY environment variable.");
+    }
+  }
+  /**
+   * Generate code from a prompt
+   */
+  async generate(prompt, options = {}) {
+    const model = options.model || "auto";
+    const context = await this.buildContext();
+    const fullPrompt = this.createPrompt(prompt, context);
+    let response;
+    let tokensUsed = 0;
+    try {
+      if (model === "gemini" || model === "auto" && this.gemini) {
+        if (!this.gemini) throw new Error("Gemini not available");
+        const result = await this.gemini.generate(fullPrompt);
+        response = result.text;
+        tokensUsed = result.tokensUsed;
+      } else if (model === "openai" || model === "auto" && this.openai) {
+        if (!this.openai) throw new Error("OpenAI not available");
+        const result = await this.openai.complete({
+          systemPrompt: "You are an expert software developer. Generate clean, production-ready code.",
+          userMessage: fullPrompt,
+          maxTokens: 8e3
+        });
+        response = result.content;
+        tokensUsed = result.tokensUsed.total;
+      } else {
+        throw new Error("No AI model available");
+      }
+    } catch (error) {
+      return {
+        success: false,
+        files: [],
+        tokensUsed: 0,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+    const files = this.parseResponse(response);
+    const maxFiles = options.maxFiles || 20;
+    if (files.length > maxFiles) {
+      return {
+        success: false,
+        files: [],
+        tokensUsed,
+        error: `Too many files generated (${files.length}). Max: ${maxFiles}`
+      };
+    }
+    if (options.dryRun) {
+      return {
+        success: true,
+        files,
+        tokensUsed
+      };
+    }
+    const writtenFiles = await this.writeFiles(files, options);
+    return {
+      success: true,
+      files: writtenFiles,
+      tokensUsed
+    };
+  }
+  /**
+   * Build context from project files
+   */
+  async buildContext() {
+    const parts = [];
+    const prdPaths = ["prd.md", "PRD.md", "docs/prd.md", "README.md"];
+    for (const prdPath of prdPaths) {
+      const fullPath = join13(this.rootDir, prdPath);
+      if (existsSync14(fullPath)) {
+        const content = readFileSync13(fullPath, "utf-8");
+        parts.push(`## ${prdPath}
+
+${content}`);
+        break;
+      }
+    }
+    if (this.config) {
+      parts.push(`## Project Info
+- Name: ${this.config.context.project.name}
+- Language: ${this.config.context.project.language}
+- Description: ${this.config.context.project.description || "N/A"}
+`);
+    }
+    return parts.join("\n\n---\n\n");
+  }
+  /**
+   * Create the full AI prompt
+   */
+  createPrompt(userPrompt, context) {
+    return `# Project Context
+
+${context}
+
+---
+
+# Task
+
+${userPrompt}
+
+---
+
+# Instructions
+
+Generate the necessary code files. Use this EXACT format for each file:
+
+\`\`\`path/to/filename.ext
+// file content here
+\`\`\`
+
+IMPORTANT:
+- Put the FULL FILE PATH in the code block language tag (e.g. \`\`\`src/index.ts)
+- Generate complete, working code - no placeholders
+- Include all necessary imports
+- Follow best practices for the language
+- One file per code block
+
+Generate the files now:`;
+  }
+  /**
+   * Parse AI response into file objects
+   */
+  parseResponse(response) {
+    const files = [];
+    const codeBlockRegex = /```([^\n`]+)\n([\s\S]*?)```/g;
+    let match;
+    while ((match = codeBlockRegex.exec(response)) !== null) {
+      const pathOrLang = match[1].trim();
+      const content = match[2];
+      if (pathOrLang.includes("/") || pathOrLang.includes("\\") || /\.\w+$/.test(pathOrLang)) {
+        const filePath = pathOrLang.replace(/\\/g, "/");
+        const ext = filePath.split(".").pop() || "";
+        const language = this.getLanguageFromExtension(ext);
+        const fullPath = join13(this.rootDir, filePath);
+        const isNew = !existsSync14(fullPath);
+        files.push({
+          path: filePath,
+          content: content.trim(),
+          isNew,
+          language
+        });
+      }
+    }
+    return files;
+  }
+  /**
+   * Get language from file extension
+   */
+  getLanguageFromExtension(ext) {
+    const map = {
+      ts: "typescript",
+      tsx: "typescript",
+      js: "javascript",
+      jsx: "javascript",
+      py: "python",
+      rs: "rust",
+      go: "go",
+      java: "java",
+      md: "markdown",
+      json: "json",
+      yaml: "yaml",
+      yml: "yaml",
+      css: "css",
+      html: "html"
+    };
+    return map[ext] || ext;
+  }
+  /**
+   * Write files to disk
+   */
+  async writeFiles(files, options) {
+    const written = [];
+    for (const file of files) {
+      const fullPath = resolve2(this.rootDir, file.path);
+      const normalizedPath = normalize3(fullPath);
+      if (!normalizedPath.startsWith(normalize3(this.rootDir))) {
+        console.warn(`Skipping file outside project root: ${file.path}`);
+        continue;
+      }
+      const dir = dirname4(fullPath);
+      if (!existsSync14(dir)) {
+        mkdirSync9(dir, { recursive: true });
+      }
+      if (!file.isNew && options.backupBeforeOverwrite) {
+        const backupPath = `${fullPath}.bak`;
+        const existingContent = readFileSync13(fullPath, "utf-8");
+        writeFileSync9(backupPath, existingContent);
+      }
+      writeFileSync9(fullPath, file.content, "utf-8");
+      written.push(file);
+    }
+    return written;
+  }
+};
+function createAIGenerator(projectDir) {
+  return new AIGenerator(projectDir);
+}
 export {
+  AIGenerator,
   ASTParser,
   AnalyticsCollector,
   AnalyticsConfigSchema,
@@ -7632,6 +7871,7 @@ export {
   calculateCost,
   checkHealth,
   chunkCode,
+  createAIGenerator,
   createAnthropicAdapter,
   createBlackboard,
   createContextAPI,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@contextos/core",
-  "version": "0.2.3",
+  "version": "0.3.0",
   "description": "Core engine for ContextOS - context management, parsing, and ranking",
   "type": "module",
   "main": "./dist/index.js",