@contextos/core 0.2.3 → 0.4.1

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,618 @@ function createLogger(config) {
 function setGlobalLogger(logger) {
   globalLogger = logger;
 }
+
+// src/generator/index.ts
+import { existsSync as existsSync16, mkdirSync as mkdirSync10, writeFileSync as writeFileSync11, readFileSync as readFileSync15 } from "fs";
+import { dirname as dirname5, join as join15, resolve as resolve2, normalize as normalize3 } from "path";
+
+// src/generator/shadow-fs.ts
+import { existsSync as existsSync14, mkdirSync as mkdirSync9, writeFileSync as writeFileSync9, readFileSync as readFileSync13, rmSync as rmSync2, renameSync, copyFileSync } from "fs";
+import { join as join13, dirname as dirname4 } from "path";
+import { randomUUID } from "crypto";
+var ShadowFileSystem = class {
+  rootDir;
+  shadowRoot;
+  activeTransactions = /* @__PURE__ */ new Map();
+  constructor(rootDir) {
+    this.rootDir = rootDir;
+    this.shadowRoot = join13(rootDir, ".contextos", ".shadow");
+  }
+  /**
+   * Begin a new transaction
+   */
+  beginTransaction() {
+    const id = randomUUID();
+    const shadowDir = join13(this.shadowRoot, id);
+    mkdirSync9(shadowDir, { recursive: true });
+    const transaction = {
+      id,
+      shadowDir,
+      files: /* @__PURE__ */ new Map(),
+      startedAt: /* @__PURE__ */ new Date(),
+      status: "active"
+    };
+    this.activeTransactions.set(id, transaction);
+    return transaction;
+  }
+  /**
+   * Write file to shadow location
+   */
+  writeToShadow(txId, relativePath, content) {
+    const tx = this.activeTransactions.get(txId);
+    if (!tx) {
+      return { success: false, error: "Transaction not found" };
+    }
+    if (tx.status !== "active") {
+      return { success: false, error: `Transaction is ${tx.status}` };
+    }
+    try {
+      const shadowPath = join13(tx.shadowDir, relativePath);
+      const shadowDir = dirname4(shadowPath);
+      if (!existsSync14(shadowDir)) {
+        mkdirSync9(shadowDir, { recursive: true });
+      }
+      writeFileSync9(shadowPath, content, "utf-8");
+      const realPath = join13(this.rootDir, relativePath);
+      tx.files.set(realPath, shadowPath);
+      return { success: true, shadowPath };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Read file from shadow or real location
+   */
+  readFile(txId, relativePath) {
+    const tx = this.activeTransactions.get(txId);
+    const realPath = join13(this.rootDir, relativePath);
+    if (tx && tx.files.has(realPath)) {
+      const shadowPath = tx.files.get(realPath);
+      if (existsSync14(shadowPath)) {
+        return readFileSync13(shadowPath, "utf-8");
+      }
+    }
+    if (existsSync14(realPath)) {
+      return readFileSync13(realPath, "utf-8");
+    }
+    return null;
+  }
+  /**
+   * Commit transaction - atomically move shadow files to real locations
+   */
+  commit(txId) {
+    const tx = this.activeTransactions.get(txId);
+    if (!tx) {
+      return { success: false, filesCommitted: 0, error: "Transaction not found" };
+    }
+    if (tx.status !== "active") {
+      return { success: false, filesCommitted: 0, error: `Transaction is ${tx.status}` };
+    }
+    let filesCommitted = 0;
+    try {
+      const backups = /* @__PURE__ */ new Map();
+      for (const [realPath, shadowPath] of tx.files) {
+        if (existsSync14(realPath)) {
+          const backupPath = `${realPath}.bak.${txId.slice(0, 8)}`;
+          copyFileSync(realPath, backupPath);
+          backups.set(realPath, backupPath);
+        }
+      }
+      for (const [realPath, shadowPath] of tx.files) {
+        const targetDir = dirname4(realPath);
+        if (!existsSync14(targetDir)) {
+          mkdirSync9(targetDir, { recursive: true });
+        }
+        renameSync(shadowPath, realPath);
+        filesCommitted++;
+      }
+      for (const backupPath of backups.values()) {
+        if (existsSync14(backupPath)) {
+          rmSync2(backupPath);
+        }
+      }
+      this.cleanupTransaction(tx);
+      tx.status = "committed";
+      return { success: true, filesCommitted };
+    } catch (error) {
+      tx.status = "rolled_back";
+      return {
+        success: false,
+        filesCommitted,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Rollback transaction - discard all shadow files
+   */
+  rollback(txId) {
+    const tx = this.activeTransactions.get(txId);
+    if (!tx) {
+      return { success: false, error: "Transaction not found" };
+    }
+    try {
+      this.cleanupTransaction(tx);
+      tx.status = "rolled_back";
+      return { success: true };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  /**
+   * Cleanup transaction resources
+   */
+  cleanupTransaction(tx) {
+    if (existsSync14(tx.shadowDir)) {
+      rmSync2(tx.shadowDir, { recursive: true, force: true });
+    }
+    this.activeTransactions.delete(tx.id);
+  }
+  /**
+   * Get transaction status
+   */
+  getTransaction(txId) {
+    return this.activeTransactions.get(txId);
+  }
+  /**
+   * List files in transaction
+   */
+  listTransactionFiles(txId) {
+    const tx = this.activeTransactions.get(txId);
+    if (!tx) return [];
+    return Array.from(tx.files.keys()).map(
+      (p) => p.replace(this.rootDir + "/", "").replace(this.rootDir + "\\", "")
+    );
+  }
+};
+function createShadowFS(rootDir) {
+  return new ShadowFileSystem(rootDir);
+}
+
+// src/context/negative-context.ts
+import { existsSync as existsSync15, readFileSync as readFileSync14, writeFileSync as writeFileSync10 } from "fs";
+import { join as join14 } from "path";
+var NegativeContextManager = class {
+  contextIgnorePath;
+  rules = [];
+  constructor(rootDir) {
+    this.contextIgnorePath = join14(rootDir, ".contextos", ".contextignore");
+    this.load();
+  }
+  /**
+   * Load rules from .contextignore
+   */
+  load() {
+    if (!existsSync15(this.contextIgnorePath)) {
+      this.rules = [];
+      return;
+    }
+    try {
+      const content = readFileSync14(this.contextIgnorePath, "utf-8");
+      const lines = content.split("\n").filter((line) => line.trim() && !line.startsWith("#"));
+      this.rules = lines.map((line) => {
+        const match = line.match(/^(\w+):(.+?)\|(.+)$/);
+        if (match) {
+          return {
+            category: match[1],
+            rule: match[2].trim(),
+            reason: match[3].trim(),
+            learnedAt: (/* @__PURE__ */ new Date()).toISOString()
+          };
+        }
+        return {
+          rule: line.trim(),
+          reason: "User defined",
+          learnedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          category: "pattern"
+        };
+      });
+    } catch {
+      this.rules = [];
+    }
+  }
+  /**
+   * Save rules to .contextignore
+   */
+  save() {
+    const header = `# ContextOS Negative Context Rules
+# Format: CATEGORY:RULE|REASON
+# Categories: library, pattern, file, approach
+# These rules are injected into AI prompts to prevent repeated mistakes
+
+`;
+    const content = this.rules.map(
+      (r) => `${r.category}:${r.rule}|${r.reason}`
+    ).join("\n");
+    writeFileSync10(this.contextIgnorePath, header + content, "utf-8");
+  }
+  /**
+   * Add a new negative rule
+   */
+  addRule(rule) {
+    if (this.rules.some((r) => r.rule === rule.rule)) {
+      return;
+    }
+    this.rules.push({
+      ...rule,
+      learnedAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    this.save();
+  }
+  /**
+   * Learn from an error
+   */
+  learnFromError(errorMessage, context) {
+    const patterns = [
+      // Library version issues
+      {
+        regex: /Module not found.*['"](.+?)['"]/i,
+        category: "library",
+        template: (match) => ({
+          rule: `Do not use ${match[1]}`,
+          reason: `Module not found: ${match[1]}`
+        })
+      },
+      // Deprecated API
+      {
+        regex: /deprecated.*['"](.+?)['"]/i,
+        category: "approach",
+        template: (match) => ({
+          rule: `Avoid deprecated API: ${match[1]}`,
+          reason: "API is deprecated"
+        })
+      },
+      // Permission denied
+      {
+        regex: /EACCES.*['"](.+?)['"]/i,
+        category: "file",
+        template: (match) => ({
+          rule: `Cannot write to ${match[1]}`,
+          reason: "Permission denied"
+        })
+      },
+      // Type errors
+      {
+        regex: /Type '(.+?)' is not assignable/i,
+        category: "pattern",
+        template: (match) => ({
+          rule: `Check type compatibility for ${match[1]}`,
+          reason: "Type mismatch error"
+        })
+      }
+    ];
+    for (const pattern of patterns) {
+      const match = errorMessage.match(pattern.regex);
+      if (match) {
+        const { rule, reason } = pattern.template(match);
+        const newRule = {
+          rule,
+          reason,
+          category: pattern.category,
+          learnedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.addRule(newRule);
+        return newRule;
+      }
+    }
+    return null;
+  }
+  /**
+   * Get all rules
+   */
+  getRules() {
+    return [...this.rules];
+  }
+  /**
+   * Get rules by category
+   */
+  getRulesByCategory(category) {
+    return this.rules.filter((r) => r.category === category);
+  }
+  /**
+   * Generate prompt injection text
+   */
+  generatePromptInjection() {
+    if (this.rules.length === 0) {
+      return "";
+    }
+    const lines = [
+      "",
+      "# IMPORTANT CONSTRAINTS (Learned from previous failures)",
+      "Do NOT violate these rules:",
+      ""
+    ];
+    for (const rule of this.rules) {
+      lines.push(`- \u274C ${rule.rule} (Reason: ${rule.reason})`);
+    }
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Clear all rules
+   */
+  clear() {
+    this.rules = [];
+    this.save();
+  }
+  /**
+   * Remove a specific rule
+   */
+  removeRule(ruleText) {
+    const index = this.rules.findIndex((r) => r.rule === ruleText);
+    if (index !== -1) {
+      this.rules.splice(index, 1);
+      this.save();
+      return true;
+    }
+    return false;
+  }
+};
+function createNegativeContextManager(rootDir) {
+  return new NegativeContextManager(rootDir);
+}
+
+// src/generator/index.ts
+var MAX_DEPTH = 3;
+var AIGenerator = class {
+  config = null;
+  gemini = null;
+  openai = null;
+  anthropic = null;
+  rootDir = process.cwd();
+  shadowFS = null;
+  negativeContext = null;
+  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 (isAnthropicAvailable()) {
+      this.anthropic = createAnthropicAdapter();
+    }
+    if (!this.gemini && !this.openai && !this.anthropic) {
+      throw new Error("No AI API key found. Set GEMINI_API_KEY, OPENAI_API_KEY, or ANTHROPIC_API_KEY environment variable.");
+    }
+    this.shadowFS = createShadowFS(this.rootDir);
+    this.negativeContext = createNegativeContextManager(this.rootDir);
+  }
+  /**
+   * Generate code from a prompt
+   */
+  async generate(prompt, options = {}) {
+    const model = options.model || "auto";
+    const depth = options.depth || 0;
+    if (depth >= MAX_DEPTH) {
+      return {
+        success: false,
+        files: [],
+        tokensUsed: 0,
+        error: `Maximum recursion depth (${MAX_DEPTH}) exceeded. Provide a heuristic summary instead.`
+      };
+    }
+    const context = await this.buildContext();
+    const negativeRules = this.negativeContext?.generatePromptInjection() || "";
+    const fullPrompt = this.createPrompt(prompt, context + negativeRules);
+    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 if (model === "anthropic" || model === "auto" && this.anthropic) {
+        if (!this.anthropic) throw new Error("Anthropic not available");
+        const result = await this.anthropic.complete({
+          systemPrompt: "You are an expert software developer. Generate clean, production-ready code.",
+          userMessage: fullPrompt,
+          maxTokens: 8e3,
+          model: "claude-3-5-sonnet-20240620"
+          // Default to 3.5 Sonnet
+        });
+        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 = join15(this.rootDir, prdPath);
+      if (existsSync16(fullPath)) {
+        const content = readFileSync15(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 = join15(this.rootDir, filePath);
+        const isNew = !existsSync16(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 = dirname5(fullPath);
+      if (!existsSync16(dir)) {
+        mkdirSync10(dir, { recursive: true });
+      }
+      if (!file.isNew && options.backupBeforeOverwrite) {
+        const backupPath = `${fullPath}.bak`;
+        const existingContent = readFileSync15(fullPath, "utf-8");
+        writeFileSync11(backupPath, existingContent);
+      }
+      writeFileSync11(fullPath, file.content, "utf-8");
+      written.push(file);
+    }
+    return written;
+  }
+};
+function createAIGenerator(projectDir) {
+  return new AIGenerator(projectDir);
+}
 export {
+  AIGenerator,
   ASTParser,
   AnalyticsCollector,
   AnalyticsConfigSchema,
@@ -7612,6 +8235,7 @@ export {
   Logger,
   MODEL_SPECIFIC_ADDENDUM,
   MetaSchema,
+  NegativeContextManager,
   OpenAIAdapter,
   PluginManager,
   PluginRegistry,
@@ -7621,6 +8245,7 @@ export {
   RLMEngine,
   RLM_BASE_SYSTEM_PROMPT,
   ScopeManager,
+  ShadowFileSystem,
   StackConfigSchema,
   SupportedLanguageSchema,
   TeamSync,
@@ -7632,6 +8257,7 @@ export {
   calculateCost,
   checkHealth,
   chunkCode,
+  createAIGenerator,
   createAnthropicAdapter,
   createBlackboard,
   createContextAPI,
@@ -7639,6 +8265,7 @@ export {
   createGeminiClient,
   createInitialUserMessage,
   createLogger,
+  createNegativeContextManager,
   createObservationMessage,
   createOpenAIAdapter,
   createPluginManager,
@@ -7648,6 +8275,7 @@ export {
   createSandbox,
   createSandboxContext,
   createScopeManager,
+  createShadowFS,
   createSubAgentResultMessage,
   createTrainingDataCollector,
   createWatchdog,

package/package.json

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