@contextos/core 0.3.0 → 0.4.1

package/dist/index.js

@@ -7592,13 +7592,371 @@ function setGlobalLogger(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";
+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();
   }
@@ -7617,17 +7975,32 @@ var AIGenerator = class {
     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.");
+    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 fullPrompt = this.createPrompt(prompt, context);
+    const negativeRules = this.negativeContext?.generatePromptInjection() || "";
+    const fullPrompt = this.createPrompt(prompt, context + negativeRules);
     let response;
     let tokensUsed = 0;
     try {
@@ -7645,6 +8018,17 @@ var AIGenerator = class {
         });
         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");
       }
@@ -7687,9 +8071,9 @@ var AIGenerator = class {
     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");
+      const fullPath = join15(this.rootDir, prdPath);
+      if (existsSync16(fullPath)) {
+        const content = readFileSync15(fullPath, "utf-8");
         parts.push(`## ${prdPath}
 
 ${content}`);
@@ -7752,8 +8136,8 @@ Generate the files now:`;
         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);
+        const fullPath = join15(this.rootDir, filePath);
+        const isNew = !existsSync16(fullPath);
         files.push({
           path: filePath,
           content: content.trim(),
@@ -7798,16 +8182,16 @@ Generate the files now:`;
         console.warn(`Skipping file outside project root: ${file.path}`);
         continue;
       }
-      const dir = dirname4(fullPath);
-      if (!existsSync14(dir)) {
-        mkdirSync9(dir, { recursive: true });
+      const dir = dirname5(fullPath);
+      if (!existsSync16(dir)) {
+        mkdirSync10(dir, { recursive: true });
       }
       if (!file.isNew && options.backupBeforeOverwrite) {
         const backupPath = `${fullPath}.bak`;
-        const existingContent = readFileSync13(fullPath, "utf-8");
-        writeFileSync9(backupPath, existingContent);
+        const existingContent = readFileSync15(fullPath, "utf-8");
+        writeFileSync11(backupPath, existingContent);
       }
-      writeFileSync9(fullPath, file.content, "utf-8");
+      writeFileSync11(fullPath, file.content, "utf-8");
       written.push(file);
     }
     return written;
@@ -7851,6 +8235,7 @@ export {
   Logger,
   MODEL_SPECIFIC_ADDENDUM,
   MetaSchema,
+  NegativeContextManager,
   OpenAIAdapter,
   PluginManager,
   PluginRegistry,
@@ -7860,6 +8245,7 @@ export {
   RLMEngine,
   RLM_BASE_SYSTEM_PROMPT,
   ScopeManager,
+  ShadowFileSystem,
   StackConfigSchema,
   SupportedLanguageSchema,
   TeamSync,
@@ -7879,6 +8265,7 @@ export {
   createGeminiClient,
   createInitialUserMessage,
   createLogger,
+  createNegativeContextManager,
   createObservationMessage,
   createOpenAIAdapter,
   createPluginManager,
@@ -7888,6 +8275,7 @@ export {
   createSandbox,
   createSandboxContext,
   createScopeManager,
+  createShadowFS,
   createSubAgentResultMessage,
   createTrainingDataCollector,
   createWatchdog,

package/package.json

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