sauron-cli 1.4.1 → 1.4.3

package/dist/index.js

@@ -4,8 +4,8 @@
 import { Command } from "commander";
 
 // src/features/init/init.command.ts
-import fs10 from "fs-extra";
-import path10 from "path";
+import fs13 from "fs-extra";
+import path13 from "path";
 import pc2 from "picocolors";
 import { fileURLToPath } from "url";
 import * as p2 from "@clack/prompts";
@@ -36,8 +36,8 @@ async function saveManifest(targetDir, manifest) {
 }
 
 // src/features/init/init.service.ts
-import fs8 from "fs-extra";
-import path8 from "path";
+import fs11 from "fs-extra";
+import path11 from "path";
 
 // src/core/merge.service.ts
 function checkConflict(localContent, newContent, manifestHash) {
@@ -146,31 +146,59 @@ var RegistryService = class {
   }
 };
 
+// src/core/registry/AdapterRegistry.ts
+var AdapterRegistry = class {
+  static adapters = /* @__PURE__ */ new Map();
+  static register(adapter) {
+    if (this.adapters.has(adapter.id)) {
+      throw new Error(`Conflito: Adaptador com ID '${adapter.id}' j\xE1 foi registrado no ecossistema.`);
+    }
+    this.adapters.set(adapter.id, adapter);
+  }
+  static resolve(ids) {
+    const resolvedAdapters = [];
+    for (const id of ids) {
+      const normalizedId = id.toLowerCase().trim();
+      const adapterInstance = this.adapters.get(normalizedId);
+      if (!adapterInstance) {
+        throw new Error(`Falha Cr\xEDtica: Agente AI '${id}' n\xE3o \xE9 suportado pela vers\xE3o atual.`);
+      }
+      resolvedAdapters.push(adapterInstance);
+    }
+    return resolvedAdapters;
+  }
+  static getAll() {
+    return Array.from(this.adapters.values());
+  }
+};
+
 // src/core/adapters/cursor.adapter.ts
 import fs3 from "fs-extra";
 import path3 from "path";
 var CursorAdapter = class {
-  getName() {
-    return "Cursor";
+  id = "cursor";
+  displayName = "Cursor IDE Engine";
+  async detect(targetDir) {
+    return fs3.pathExists(path3.join(targetDir, ".cursor"));
   }
-  async inject(cwd, rulesContent) {
-    const rulesDir = path3.join(cwd, ".cursor", "rules");
+  async inject(payload, targetDir) {
+    const rulesDir = path3.join(targetDir, ".cursor", "rules");
     await fs3.ensureDir(rulesDir);
     const mdcPath = path3.join(rulesDir, "sauron-memory.mdc");
     const mdcContent = `---
 description: Diretrizes de Mem\xF3ria e Write Obligation para evitar Amn\xE9sia de Contexto
-globs: *
+globs: ${payload.ruleScope || "*"}
 ---
 
 # SAURON START
-${rulesContent}
+${payload.globalRules}
 # SAURON END
 `;
     await fs3.writeFile(mdcPath, mdcContent, "utf8");
     return [".cursor/rules/sauron-memory.mdc"];
   }
-  async clean(cwd) {
-    const mdcPath = path3.join(cwd, ".cursor", "rules", "sauron-memory.mdc");
+  async clean(targetDir) {
+    const mdcPath = path3.join(targetDir, ".cursor", "rules", "sauron-memory.mdc");
     if (await fs3.pathExists(mdcPath)) {
       await fs3.remove(mdcPath);
       return [".cursor/rules/sauron-memory.mdc"];
@@ -183,38 +211,60 @@ ${rulesContent}
 import fs4 from "fs-extra";
 import path4 from "path";
 var WindsurfAdapter = class {
-  getName() {
-    return "Windsurf";
-  }
-  async inject(cwd, rulesContent) {
-    const rulesPath = path4.join(cwd, ".windsurfrules");
-    let localContent = "";
-    if (await fs4.pathExists(rulesPath)) {
-      localContent = await fs4.readFile(rulesPath, "utf8");
-    }
-    const cleanedContent = this.removeSauronBlock(localContent);
-    const sauronBlock = `
-# SAURON START
-${rulesContent}
-# SAURON END
+  id = "windsurf";
+  displayName = "Windsurf by Codeium";
+  async detect(targetDir) {
+    return fs4.pathExists(path4.join(targetDir, ".windsurf"));
+  }
+  async inject(payload, targetDir) {
+    const modifications = [];
+    const rulesDir = path4.join(targetDir, ".windsurf", "rules");
+    await fs4.ensureDir(rulesDir);
+    const ruleContent = `---
+description: "Sauron Memory Override - Universal Guidelines and Base Types"
+trigger: always_on
+---
+
+# Overarching Project Context
+${payload.globalRules}
+
+*Note: For dynamic capabilities, rely on native skill sets; for fundamental structures, observe these bounds.*
 `;
-    const finalContent = (cleanedContent.trim() + "\n" + sauronBlock).trim() + "\n";
-    await fs4.writeFile(rulesPath, finalContent, "utf8");
-    return [".windsurfrules"];
-  }
-  async clean(cwd) {
-    const rulesPath = path4.join(cwd, ".windsurfrules");
-    if (!await fs4.pathExists(rulesPath)) {
-      return [];
+    const mdPath = path4.join(rulesDir, "sauron-memory.md");
+    await fs4.outputFile(mdPath, ruleContent, "utf-8");
+    modifications.push(".windsurf/rules/sauron-memory.md");
+    const oldPath = path4.join(targetDir, ".windsurfrules");
+    if (await fs4.pathExists(oldPath)) {
+      const localContent = await fs4.readFile(oldPath, "utf8");
+      const cleanedContent = this.removeSauronBlock(localContent).trim();
+      if (cleanedContent === "") {
+        await fs4.remove(oldPath);
+      } else {
+        await fs4.writeFile(oldPath, cleanedContent + "\n", "utf8");
+      }
+      modifications.push(".windsurfrules");
     }
-    const localContent = await fs4.readFile(rulesPath, "utf8");
-    const cleanedContent = this.removeSauronBlock(localContent).trim();
-    if (cleanedContent === "") {
-      await fs4.remove(rulesPath);
-    } else {
-      await fs4.writeFile(rulesPath, cleanedContent + "\n", "utf8");
+    return modifications;
+  }
+  async clean(targetDir) {
+    const modifications = [];
+    const mdPath = path4.join(targetDir, ".windsurf", "rules", "sauron-memory.md");
+    if (await fs4.pathExists(mdPath)) {
+      await fs4.remove(mdPath);
+      modifications.push(".windsurf/rules/sauron-memory.md");
+    }
+    const oldPath = path4.join(targetDir, ".windsurfrules");
+    if (await fs4.pathExists(oldPath)) {
+      const localContent = await fs4.readFile(oldPath, "utf8");
+      const cleanedContent = this.removeSauronBlock(localContent).trim();
+      if (cleanedContent === "") {
+        await fs4.remove(oldPath);
+      } else {
+        await fs4.writeFile(oldPath, cleanedContent + "\n", "utf8");
+      }
+      modifications.push(".windsurfrules");
     }
-    return [".windsurfrules"];
+    return modifications;
   }
   removeSauronBlock(content) {
     const regex = /# SAURON START[\s\S]*?# SAURON END/g;
@@ -225,26 +275,90 @@ ${rulesContent}
 // src/core/adapters/aider.adapter.ts
 import fs5 from "fs-extra";
 import path5 from "path";
+import * as yaml from "js-yaml";
+function isAiderConfigValid(config) {
+  return typeof config === "object" && config !== null;
+}
 var AiderAdapter = class {
-  getName() {
-    return "Aider";
-  }
-  async inject(cwd, rulesContent) {
-    const rulesPath = path5.join(cwd, ".aider.instructions.md");
-    const content = `# SAURON START
-${rulesContent}
-# SAURON END
-`;
-    await fs5.writeFile(rulesPath, content, "utf8");
-    return [".aider.instructions.md"];
-  }
-  async clean(cwd) {
-    const rulesPath = path5.join(cwd, ".aider.instructions.md");
-    if (await fs5.pathExists(rulesPath)) {
-      await fs5.remove(rulesPath);
-      return [".aider.instructions.md"];
+  id = "aider";
+  displayName = "Aider Agent CLI";
+  async detect(targetDir) {
+    return fs5.pathExists(path5.join(targetDir, ".aider.conf.yml"));
+  }
+  async inject(payload, targetDir) {
+    const modifications = [];
+    const memoryFileName = ".sauron-aider-instructions.md";
+    const instructionsPath = path5.join(targetDir, memoryFileName);
+    await fs5.outputFile(instructionsPath, payload.globalRules, "utf-8");
+    modifications.push(memoryFileName);
+    const configPath = path5.join(targetDir, ".aider.conf.yml");
+    let configObj = {};
+    if (await fs5.pathExists(configPath)) {
+      try {
+        const configStr = await fs5.readFile(configPath, "utf8");
+        configObj = yaml.load(configStr) || {};
+      } catch (err) {
+        throw new Error(`O YAML subjacente em ${configPath} est\xE1 corrompido ou malformado.`);
+      }
     }
-    return [];
+    if (isAiderConfigValid(configObj)) {
+      if (!configObj.read) {
+        configObj.read = [];
+      } else if (typeof configObj.read === "string") {
+        configObj.read = [configObj.read];
+      }
+      if (Array.isArray(configObj.read) && !configObj.read.includes(memoryFileName)) {
+        configObj.read.push(memoryFileName);
+      }
+      const newYamlDump = yaml.dump(configObj, { indent: 2, lineWidth: -1 });
+      await fs5.outputFile(configPath, newYamlDump, "utf-8");
+      modifications.push(".aider.conf.yml");
+    } else {
+      throw new Error("Falha no cast. A estrutura lida do '.aider.conf.yml' n\xE3o corresponde a um objeto mape\xE1vel.");
+    }
+    const oldPath = path5.join(targetDir, ".aider.instructions.md");
+    if (await fs5.pathExists(oldPath)) {
+      await fs5.remove(oldPath);
+      modifications.push(".aider.instructions.md");
+    }
+    return modifications;
+  }
+  async clean(targetDir) {
+    const modifications = [];
+    const memoryFileName = ".sauron-aider-instructions.md";
+    const instructionsPath = path5.join(targetDir, memoryFileName);
+    if (await fs5.pathExists(instructionsPath)) {
+      await fs5.remove(instructionsPath);
+      modifications.push(memoryFileName);
+    }
+    const configPath = path5.join(targetDir, ".aider.conf.yml");
+    if (await fs5.pathExists(configPath)) {
+      try {
+        const configStr = await fs5.readFile(configPath, "utf8");
+        const configObj = yaml.load(configStr);
+        if (isAiderConfigValid(configObj) && Array.isArray(configObj.read)) {
+          const newRead = configObj.read.filter((p5) => p5 !== memoryFileName);
+          if (newRead.length !== configObj.read.length) {
+            configObj.read = newRead;
+            if (configObj.read.length === 0) delete configObj.read;
+            const newYamlDump = yaml.dump(configObj, { indent: 2, lineWidth: -1 });
+            if (Object.keys(configObj).length === 0) {
+              await fs5.remove(configPath);
+            } else {
+              await fs5.outputFile(configPath, newYamlDump, "utf-8");
+            }
+            modifications.push(".aider.conf.yml");
+          }
+        }
+      } catch (err) {
+      }
+    }
+    const oldPath = path5.join(targetDir, ".aider.instructions.md");
+    if (await fs5.pathExists(oldPath)) {
+      await fs5.remove(oldPath);
+      modifications.push(".aider.instructions.md");
+    }
+    return modifications;
   }
 };
 
@@ -252,25 +366,27 @@ ${rulesContent}
 import fs6 from "fs-extra";
 import path6 from "path";
 var AntigravityAdapter = class {
-  getName() {
-    return "Antigravity";
+  id = "antigravity";
+  displayName = "Antigravity IDE Engine";
+  async detect(targetDir) {
+    return fs6.pathExists(path6.join(targetDir, ".agents"));
   }
-  async inject(cwd, rulesContent) {
-    const rulesPath = path6.join(cwd, ".agents", "rules", "memory.md");
+  async inject(payload, targetDir) {
+    const rulesPath = path6.join(targetDir, ".agents", "rules", "memory.md");
     await fs6.ensureDir(path6.dirname(rulesPath));
     const content = `---
 trigger: always_on
 ---
 
 # SAURON START
-${rulesContent}
+${payload.globalRules}
 # SAURON END
 `;
     await fs6.writeFile(rulesPath, content, "utf8");
     return [".agents/rules/memory.md"];
   }
-  async clean(cwd) {
-    const agentsDir = path6.join(cwd, ".agents");
+  async clean(targetDir) {
+    const agentsDir = path6.join(targetDir, ".agents");
     if (await fs6.pathExists(agentsDir)) {
       await fs6.remove(agentsDir);
       return [".agents/rules/memory.md", ".agents/skills/wiki/SKILL.md"];
@@ -279,75 +395,193 @@ ${rulesContent}
   }
 };
 
-// src/core/adapters/adapter.factory.ts
-var AdapterFactory = class {
-  static getAdapter(name) {
-    switch (name.trim().toLowerCase()) {
-      case "cursor":
-        return new CursorAdapter();
-      case "windsurf":
-        return new WindsurfAdapter();
-      case "aider":
-        return new AiderAdapter();
-      case "antigravity":
-        return new AntigravityAdapter();
-      default:
-        return null;
+// src/core/adapters/opencode.adapter.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+var OpencodeAdapter = class {
+  id = "opencode";
+  displayName = "Opencode Multi-Model Interface";
+  async detect(targetDir) {
+    return fs7.pathExists(path7.join(targetDir, "opencode.json"));
+  }
+  async inject(payload, targetDir) {
+    const modifications = [];
+    const instructionDir = path7.join(targetDir, ".opencode", "instructions");
+    await fs7.ensureDir(instructionDir);
+    const rulesPath = path7.join(instructionDir, "sauron-memory.md");
+    await fs7.outputFile(rulesPath, payload.globalRules, "utf-8");
+    modifications.push(".opencode/instructions/sauron-memory.md");
+    const configPath = path7.join(targetDir, "opencode.json");
+    let configObj = {};
+    if (await fs7.pathExists(configPath)) {
+      try {
+        configObj = await fs7.readJson(configPath);
+      } catch (e) {
+        throw new Error("Falha no parse do arquivo base opencode.json. JSON inv\xE1lido detectado.");
+      }
+    }
+    if (!Array.isArray(configObj.instructions)) {
+      configObj.instructions = configObj.instructions ? [configObj.instructions] : [];
     }
+    const relativeRulesPath = ".opencode/instructions/sauron-memory.md";
+    if (!configObj.instructions.includes(relativeRulesPath)) {
+      configObj.instructions.push(relativeRulesPath);
+      await fs7.writeJson(configPath, configObj, { spaces: 2 });
+      modifications.push("opencode.json");
+    }
+    return modifications;
+  }
+  async clean(targetDir) {
+    const modifications = [];
+    const rulesPath = path7.join(targetDir, ".opencode", "instructions", "sauron-memory.md");
+    if (await fs7.pathExists(rulesPath)) {
+      await fs7.remove(rulesPath);
+      modifications.push(".opencode/instructions/sauron-memory.md");
+    }
+    const configPath = path7.join(targetDir, "opencode.json");
+    if (await fs7.pathExists(configPath)) {
+      try {
+        const configObj = await fs7.readJson(configPath);
+        if (Array.isArray(configObj.instructions)) {
+          const relativeRulesPath = ".opencode/instructions/sauron-memory.md";
+          const newInstructions = configObj.instructions.filter((i) => i !== relativeRulesPath);
+          if (newInstructions.length !== configObj.instructions.length) {
+            configObj.instructions = newInstructions;
+            if (configObj.instructions.length === 0) delete configObj.instructions;
+            if (Object.keys(configObj).length === 0) {
+              await fs7.remove(configPath);
+            } else {
+              await fs7.writeJson(configPath, configObj, { spaces: 2 });
+            }
+            modifications.push("opencode.json");
+          }
+        }
+      } catch (e) {
+      }
+    }
+    return modifications;
   }
-  static getAllAdapters() {
-    return [
-      new CursorAdapter(),
-      new WindsurfAdapter(),
-      new AiderAdapter(),
-      new AntigravityAdapter()
-    ];
+};
+
+// src/core/adapters/codex.adapter.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+var CodexAdapter = class {
+  id = "codex";
+  displayName = "Codex Local Sandbox";
+  async detect(targetDir) {
+    return fs8.pathExists(path8.join(targetDir, ".codex"));
+  }
+  async inject(payload, targetDir) {
+    const rulesDir = path8.join(targetDir, ".codex", "rules");
+    await fs8.ensureDir(rulesDir);
+    const codexPolicy = `prompt: true
+allow:
+  - read: .sauron/wiki/**
+  - read: AGENTS.md
+  
+# Sauron Central Governance Policy
+${payload.globalRules}
+`;
+    const outputPath = path8.join(rulesDir, "sauron-memory.rules");
+    await fs8.outputFile(outputPath, codexPolicy, "utf-8");
+    return [".codex/rules/sauron-memory.rules"];
+  }
+  async clean(targetDir) {
+    const rulesPath = path8.join(targetDir, ".codex", "rules", "sauron-memory.rules");
+    if (await fs8.pathExists(rulesPath)) {
+      await fs8.remove(rulesPath);
+      return [".codex/rules/sauron-memory.rules"];
+    }
+    return [];
   }
 };
 
+// src/core/adapters/claude.adapter.ts
+import fs9 from "fs-extra";
+import path9 from "path";
+var ClaudeAdapter = class {
+  id = "claude";
+  displayName = "Claude Code CLI";
+  async detect(targetDir) {
+    return fs9.pathExists(path9.join(targetDir, ".claude"));
+  }
+  async inject(payload, targetDir) {
+    const rulesDir = path9.join(targetDir, ".claude", "rules");
+    await fs9.ensureDir(rulesDir);
+    const claudeRuleContent = `# Sauron Governance Directives
+      
+## Context Inheritance
+As per architectural guidelines, Claude must persistently obey instructions centralized in the global ${payload.fallbackReference || "AGENTS.md"} file within this project root.
+
+## Local Addendum Context
+${payload.globalRules}`;
+    const outputPath = path9.join(rulesDir, "sauron-base.md");
+    await fs9.outputFile(outputPath, claudeRuleContent, "utf-8");
+    return [".claude/rules/sauron-base.md"];
+  }
+  async clean(targetDir) {
+    const rulesPath = path9.join(targetDir, ".claude", "rules", "sauron-base.md");
+    if (await fs9.pathExists(rulesPath)) {
+      await fs9.remove(rulesPath);
+      return [".claude/rules/sauron-base.md"];
+    }
+    return [];
+  }
+};
+
+// src/core/adapters/index.ts
+AdapterRegistry.register(new CursorAdapter());
+AdapterRegistry.register(new WindsurfAdapter());
+AdapterRegistry.register(new AiderAdapter());
+AdapterRegistry.register(new AntigravityAdapter());
+AdapterRegistry.register(new OpencodeAdapter());
+AdapterRegistry.register(new CodexAdapter());
+AdapterRegistry.register(new ClaudeAdapter());
+
 // src/core/wiki/wiki-bootstrapper.ts
-import fs7 from "fs-extra";
-import path7 from "path";
+import fs10 from "fs-extra";
+import path10 from "path";
 var WikiBootstrapper = class {
   constructor(projectRoot) {
     this.projectRoot = projectRoot;
-    this.wikiDir = path7.join(projectRoot, ".sauron", "wiki");
-    this.standardsDir = path7.join(this.wikiDir, "standards");
+    this.wikiDir = path10.join(projectRoot, ".sauron", "wiki");
+    this.standardsDir = path10.join(this.wikiDir, "standards");
   }
   projectRoot;
   standardsDir;
   wikiDir;
   async bootstrapFromTemplates(templatesDir, wikiTemplatesToInject) {
     const injectedFiles = [];
-    const recipesSrcDir = path7.join(templatesDir, "wiki-recipes");
-    if (!await fs7.pathExists(recipesSrcDir)) {
+    const recipesSrcDir = path10.join(templatesDir, "wiki-recipes");
+    if (!await fs10.pathExists(recipesSrcDir)) {
       return [];
     }
-    await fs7.ensureDir(this.standardsDir);
-    const summaryPath = path7.join(this.wikiDir, "summary.json");
+    await fs10.ensureDir(this.standardsDir);
+    const summaryPath = path10.join(this.wikiDir, "summary.json");
     let summary = [];
-    if (await fs7.pathExists(summaryPath)) {
+    if (await fs10.pathExists(summaryPath)) {
       try {
-        summary = await fs7.readJson(summaryPath);
+        summary = await fs10.readJson(summaryPath);
       } catch (err) {
         summary = [];
       }
     }
     for (const templateName of wikiTemplatesToInject) {
-      const srcTemplatePath = path7.join(recipesSrcDir, templateName);
-      if (!await fs7.pathExists(srcTemplatePath)) {
+      const srcTemplatePath = path10.join(recipesSrcDir, templateName);
+      if (!await fs10.pathExists(srcTemplatePath)) {
         continue;
       }
       const destFilename = templateName;
-      const destFullPath = path7.join(this.standardsDir, destFilename);
+      const destFullPath = path10.join(this.standardsDir, destFilename);
       const relWikiPath = `standards/${destFilename}`;
-      const content = await fs7.readFile(srcTemplatePath, "utf8");
+      const content = await fs10.readFile(srcTemplatePath, "utf8");
       const hash = generateHash(content);
       const len = Buffer.byteLength(content, "utf8");
-      const exists = await fs7.pathExists(destFullPath);
+      const exists = await fs10.pathExists(destFullPath);
       if (!exists) {
-        await fs7.writeFile(destFullPath, content, "utf8");
-        injectedFiles.push(path7.join(".sauron", "wiki", relWikiPath).replace(/\\/g, "/"));
+        await fs10.writeFile(destFullPath, content, "utf8");
+        injectedFiles.push(path10.join(".sauron", "wiki", relWikiPath).replace(/\\/g, "/"));
       }
       const slug = destFilename.replace(".rules.md", "").replace(".rules.txt", "");
       const docName = this.inferDocName(slug);
@@ -374,7 +608,7 @@ var WikiBootstrapper = class {
         summary.push(newItem);
       }
     }
-    await fs7.writeJson(summaryPath, summary, { spaces: 2 });
+    await fs10.writeJson(summaryPath, summary, { spaces: 2 });
     return injectedFiles;
   }
   inferDocName(slug) {
@@ -403,25 +637,25 @@ var InitService = class {
     const manifest = await getManifest(cwd) || { version: "1.0.0", files: {} };
     const modifiedFiles = [];
     const processDirectory = async (source, target) => {
-      if (!await fs8.pathExists(source)) return;
-      const files = await fs8.readdir(source);
+      if (!await fs11.pathExists(source)) return;
+      const files = await fs11.readdir(source);
       for (const file of files) {
-        const sourcePath = path8.join(source, file);
-        const targetPath = path8.join(target, file);
-        const stat = await fs8.stat(sourcePath);
+        const sourcePath = path11.join(source, file);
+        const targetPath = path11.join(target, file);
+        const stat = await fs11.stat(sourcePath);
         if (stat.isDirectory()) {
-          const relativeToTarget = path8.relative(cwd, targetPath).replace(/\\/g, "/");
-          if (relativeToTarget === ".sauron/wiki" && await fs8.pathExists(targetPath)) {
+          const relativeToTarget = path11.relative(cwd, targetPath).replace(/\\/g, "/");
+          if (relativeToTarget === ".sauron/wiki" && await fs11.pathExists(targetPath)) {
             continue;
           }
-          await fs8.ensureDir(targetPath);
+          await fs11.ensureDir(targetPath);
           await processDirectory(sourcePath, targetPath);
         } else {
-          const content = await fs8.readFile(sourcePath, "utf8");
-          const relPath = path8.relative(cwd, targetPath).replace(/\\/g, "/");
+          const content = await fs11.readFile(sourcePath, "utf8");
+          const relPath = path11.relative(cwd, targetPath).replace(/\\/g, "/");
           let shouldWrite = true;
-          if (await fs8.pathExists(targetPath)) {
-            const localContent = await fs8.readFile(targetPath, "utf8");
+          if (await fs11.pathExists(targetPath)) {
+            const localContent = await fs11.readFile(targetPath, "utf8");
             const hasConflict = checkConflict(localContent, content, manifest.files[relPath]);
             if (hasConflict) {
               const decision = await driver.resolveConflict(relPath, localContent, content);
@@ -430,10 +664,10 @@ var InitService = class {
               }
             }
           } else {
-            await fs8.ensureDir(path8.dirname(targetPath));
+            await fs11.ensureDir(path11.dirname(targetPath));
           }
           if (shouldWrite) {
-            await fs8.writeFile(targetPath, content, "utf8");
+            await fs11.writeFile(targetPath, content, "utf8");
             modifiedFiles.push(relPath);
           }
           const isMutable = relPath.startsWith(".sauron/wiki/") || relPath === ".agents/rules/memory.md";
@@ -443,9 +677,9 @@ var InitService = class {
         }
       }
     };
-    await processDirectory(path8.join(templatesDir, ".sauron"), path8.join(cwd, ".sauron"));
-    await processDirectory(path8.join(templatesDir, ".agents"), path8.join(cwd, ".agents"));
-    const agentsMdPath = path8.join(cwd, "AGENTS.md");
+    await processDirectory(path11.join(templatesDir, ".sauron"), path11.join(cwd, ".sauron"));
+    await processDirectory(path11.join(templatesDir, ".agents"), path11.join(cwd, ".agents"));
+    const agentsMdPath = path11.join(cwd, "AGENTS.md");
     const agentsMdContent = generateAgentsMarkdown(
       options.aiTargets,
       options.severity,
@@ -453,8 +687,8 @@ var InitService = class {
       options.projectStack
     );
     let shouldWriteAgents = true;
-    if (await fs8.pathExists(agentsMdPath)) {
-      const localAgents = await fs8.readFile(agentsMdPath, "utf8");
+    if (await fs11.pathExists(agentsMdPath)) {
+      const localAgents = await fs11.readFile(agentsMdPath, "utf8");
       const hasConflict = checkConflict(localAgents, agentsMdContent, manifest.files["AGENTS.md"]);
       if (hasConflict) {
         const decision = await driver.resolveConflict("AGENTS.md", localAgents, agentsMdContent);
@@ -464,7 +698,7 @@ var InitService = class {
       }
     }
     if (shouldWriteAgents) {
-      await fs8.writeFile(agentsMdPath, agentsMdContent, "utf8");
+      await fs11.writeFile(agentsMdPath, agentsMdContent, "utf8");
       modifiedFiles.push("AGENTS.md");
     }
     manifest.files["AGENTS.md"] = generateHash(agentsMdContent);
@@ -476,19 +710,28 @@ var InitService = class {
     };
     await saveManifest(cwd, manifest);
     modifiedFiles.push(".sauron/.manifest.json");
-    const memoryFilePath = path8.join(cwd, ".agents", "rules", "memory.md");
+    const memoryFilePath = path11.join(cwd, ".agents", "rules", "memory.md");
     let memoryRulesContent = "";
-    if (await fs8.pathExists(memoryFilePath)) {
-      memoryRulesContent = await fs8.readFile(memoryFilePath, "utf8");
+    if (await fs11.pathExists(memoryFilePath)) {
+      memoryRulesContent = await fs11.readFile(memoryFilePath, "utf8");
     } else {
       memoryRulesContent = agentsMdContent;
     }
-    for (const target of options.aiTargets) {
-      const adapter = AdapterFactory.getAdapter(target);
-      if (adapter) {
-        const paths = await adapter.inject(cwd, memoryRulesContent);
+    const projectName = path11.basename(cwd) || "Unnamed Project";
+    const memoryPayload = {
+      projectName,
+      globalRules: memoryRulesContent,
+      ruleScope: "**/*.{ts,js,tsx,jsx}",
+      fallbackReference: "AGENTS.md"
+    };
+    try {
+      const adapters = AdapterRegistry.resolve(options.aiTargets);
+      for (const adapter of adapters) {
+        const paths = await adapter.inject(memoryPayload, cwd);
         modifiedFiles.push(...paths);
       }
+    } catch (error) {
+      throw new Error(`Erro ao orquestrar adaptadores: ${error.message}`);
     }
     const bootstrapper = new WikiBootstrapper(cwd);
     const injectedWikiFiles = await bootstrapper.bootstrapFromTemplates(
@@ -496,7 +739,6 @@ var InitService = class {
       options.wikiTemplatesToInject
     );
     modifiedFiles.push(...injectedWikiFiles);
-    const projectName = path8.basename(cwd) || "Unnamed Project";
     await this.registryService.registerWorkspace(
       projectName,
       cwd,
@@ -711,8 +953,8 @@ var PresentationRouter = class {
 };
 
 // src/core/scanner/project-scanner.ts
-import fs9 from "fs-extra";
-import path9 from "path";
+import fs12 from "fs-extra";
+import path12 from "path";
 
 // src/core/scanner/signatures.ts
 var TECHNOLOGY_SIGNATURES = [
@@ -805,7 +1047,7 @@ var ProjectScanner = class {
       wikiTemplatesToInject: []
     };
     try {
-      const rootEntries = await fs9.readdir(this.cwd, { withFileTypes: true });
+      const rootEntries = await fs12.readdir(this.cwd, { withFileTypes: true });
       const rootFiles = rootEntries.filter((e) => e.isFile()).map((e) => e.name);
       const rootDirs = rootEntries.filter((e) => e.isDirectory()).map((e) => e.name);
       if (rootFiles.includes("pnpm-lock.yaml") || rootFiles.includes("pnpm-workspace.yaml")) {
@@ -837,8 +1079,8 @@ var ProjectScanner = class {
         context.detectedIAs = ["Cursor", "Windsurf", "Aider", "Antigravity"];
       }
       if (rootFiles.includes("package.json")) {
-        const pkgPath = path9.join(this.cwd, "package.json");
-        const pkg = await fs9.readJson(pkgPath);
+        const pkgPath = path12.join(this.cwd, "package.json");
+        const pkg = await fs12.readJson(pkgPath);
         const allDeps = {
           ...pkg.dependencies || {},
           ...pkg.devDependencies || {}
@@ -859,8 +1101,8 @@ var ProjectScanner = class {
       const composeFiles = ["compose.yml", "docker-compose.yml"];
       for (const composeFile of composeFiles) {
         if (rootFiles.includes(composeFile)) {
-          const composePath = path9.join(this.cwd, composeFile);
-          const composeContent = await fs9.readFile(composePath, "utf8");
+          const composePath = path12.join(this.cwd, composeFile);
+          const composeContent = await fs12.readFile(composePath, "utf8");
           for (const sig of TECHNOLOGY_SIGNATURES) {
             if (sig.regex && sig.regex.file === composeFile) {
               if (sig.regex.pattern.test(composeContent)) {
@@ -894,7 +1136,7 @@ var ProjectScanner = class {
 
 // src/features/init/init.command.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path10.dirname(__filename);
+var __dirname = path13.dirname(__filename);
 async function runInitCommand(options) {
   const cwd = process.cwd();
   const session = new SessionContext({
@@ -948,9 +1190,9 @@ async function runInitCommand(options) {
       projectContext = manifestData.config.projectContext;
       projectStack = manifestData.config.projectStack;
     } else {
-      const agentsMdPath = path10.join(cwd, "AGENTS.md");
-      if (await fs10.pathExists(agentsMdPath)) {
-        const content = await fs10.readFile(agentsMdPath, "utf8");
+      const agentsMdPath = path13.join(cwd, "AGENTS.md");
+      if (await fs13.pathExists(agentsMdPath)) {
+        const content = await fs13.readFile(agentsMdPath, "utf8");
         const targetsMatch = content.match(/\*\*Targets:\*\* (.*)/);
         if (targetsMatch) aiTargets = targetsMatch[1].split(",").map((s) => s.trim());
         const severityMatch = content.match(/\*\*Severity:\*\* (.*)/);
@@ -982,6 +1224,9 @@ async function runInitCommand(options) {
             options: [
               { value: "Cursor", label: "Cursor", hint: "Recomendado" },
               { value: "Windsurf", label: "Windsurf" },
+              { value: "Claude", label: "Claude Code" },
+              { value: "Codex", label: "Codex" },
+              { value: "Opencode", label: "Opencode" },
               { value: "Aider", label: "Aider" },
               { value: "Antigravity", label: "Antigravity", hint: "Agente nativo" }
             ],
@@ -1024,9 +1269,9 @@ async function runInitCommand(options) {
     }
   }
   driver.startSpinner("Injetando o C\xE9rebro da IA no reposit\xF3rio...");
-  let templatesDir = path10.join(__dirname, "..", "templates");
-  if (!fs10.existsSync(templatesDir)) {
-    templatesDir = path10.join(__dirname, "..", "..", "..", "templates");
+  let templatesDir = path13.join(__dirname, "..", "templates");
+  if (!fs13.existsSync(templatesDir)) {
+    templatesDir = path13.join(__dirname, "..", "..", "..", "templates");
   }
   const initService = new InitService();
   try {
@@ -1048,7 +1293,7 @@ async function runInitCommand(options) {
       success: true,
       message,
       payload: {
-        projectName: path10.basename(cwd),
+        projectName: path13.basename(cwd),
         cwd,
         aiTargets,
         severity,
@@ -1066,16 +1311,16 @@ import pc3 from "picocolors";
 import * as p3 from "@clack/prompts";
 
 // src/features/doctor/doctor.service.ts
-import fs11 from "fs-extra";
-import path11 from "path";
+import fs14 from "fs-extra";
+import path14 from "path";
 var DoctorService = class {
   registryService = new RegistryService();
   async execute(cwd) {
     const issues = [];
     const workspaces = await this.registryService.listWorkspaces();
-    const normalizedCwd = path11.resolve(cwd).replace(/\\/g, "/");
+    const normalizedCwd = path14.resolve(cwd).replace(/\\/g, "/");
     const registered = workspaces.find(
-      (w) => path11.resolve(w.rootPath).replace(/\\/g, "/") === normalizedCwd
+      (w) => path14.resolve(w.rootPath).replace(/\\/g, "/") === normalizedCwd
     );
     if (!registered) {
       issues.push({
@@ -1093,8 +1338,8 @@ var DoctorService = class {
       });
     } else {
       for (const [relPath, expectedHash] of Object.entries(manifest.files)) {
-        const fullPath = path11.join(cwd, relPath);
-        if (!await fs11.pathExists(fullPath)) {
+        const fullPath = path14.join(cwd, relPath);
+        if (!await fs14.pathExists(fullPath)) {
           issues.push({
             severity: "error",
             message: `Arquivo gerenciado pelo manifesto est\xE1 ausente: ${relPath}`,
@@ -1103,7 +1348,7 @@ var DoctorService = class {
           });
           continue;
         }
-        const fileContent = await fs11.readFile(fullPath, "utf8");
+        const fileContent = await fs14.readFile(fullPath, "utf8");
         const computedHash = generateHash(fileContent);
         if (computedHash !== expectedHash) {
           issues.push({
@@ -1115,8 +1360,8 @@ var DoctorService = class {
         }
       }
     }
-    const summaryPath = path11.join(cwd, ".sauron", "wiki", "summary.json");
-    if (!await fs11.pathExists(summaryPath)) {
+    const summaryPath = path14.join(cwd, ".sauron", "wiki", "summary.json");
+    if (!await fs14.pathExists(summaryPath)) {
       issues.push({
         severity: "error",
         message: "Arquivo de sum\xE1rio da wiki (.sauron/wiki/summary.json) est\xE1 ausente.",
@@ -1124,13 +1369,13 @@ var DoctorService = class {
       });
     } else {
       try {
-        const summary = await fs11.readJson(summaryPath);
+        const summary = await fs14.readJson(summaryPath);
         if (Array.isArray(summary)) {
           for (const item of summary) {
             if (item.type === "file") {
-              const fileRelPath = path11.join(".sauron", "wiki", item.path).replace(/\\/g, "/");
-              const fileFullPath = path11.join(cwd, ".sauron", "wiki", item.path);
-              if (!await fs11.pathExists(fileFullPath)) {
+              const fileRelPath = path14.join(".sauron", "wiki", item.path).replace(/\\/g, "/");
+              const fileFullPath = path14.join(cwd, ".sauron", "wiki", item.path);
+              if (!await fs14.pathExists(fileFullPath)) {
                 issues.push({
                   severity: "error",
                   message: `Documento catalogado no sum\xE1rio est\xE1 ausente: ${fileRelPath}`,
@@ -1139,7 +1384,7 @@ var DoctorService = class {
                 });
                 continue;
               }
-              const content = await fs11.readFile(fileFullPath, "utf8");
+              const content = await fs14.readFile(fileFullPath, "utf8");
               const computedHash = generateHash(content);
               const computedLen = Buffer.byteLength(content, "utf8");
               if (item.contentHash && computedHash !== item.contentHash) {
@@ -1177,37 +1422,41 @@ var DoctorService = class {
     }
     const targets = registered?.aiTargets || ["Cursor", "Windsurf", "Aider", "Antigravity"];
     for (const target of targets) {
-      const adapter = AdapterFactory.getAdapter(target);
-      if (adapter) {
-        const rulesFileMap = {
-          "Cursor": ".cursor/rules/sauron-memory.mdc",
-          "Windsurf": ".windsurfrules",
-          "Aider": ".aider.instructions.md",
-          "Antigravity": ".agents/rules/memory.md"
-        };
-        const relPath = rulesFileMap[target];
-        if (relPath) {
-          const fullPath = path11.join(cwd, relPath);
-          if (!await fs11.pathExists(fullPath)) {
-            issues.push({
-              severity: "error",
-              message: `Configura\xE7\xE3o do agente ${target} est\xE1 ausente ou foi deletada: ${relPath}`,
-              fix: `Rode sauron init para reinjetar a integra\xE7\xE3o com o ${target}.`
-            });
-          } else {
-            const rulesContent = await fs11.readFile(fullPath, "utf8");
-            const hasStart = rulesContent.includes("# SAURON START");
-            const hasEnd = rulesContent.includes("# SAURON END");
-            if (!hasStart || !hasEnd) {
+      try {
+        const adapters = AdapterRegistry.resolve([target]);
+        if (adapters.length > 0) {
+          const rulesFileMap = {
+            "cursor": ".cursor/rules/sauron-memory.mdc",
+            "windsurf": ".windsurf/rules/sauron-memory.md",
+            "aider": ".sauron-aider-instructions.md",
+            "antigravity": ".agents/rules/memory.md",
+            "opencode": ".opencode/instructions/sauron-memory.md",
+            "codex": ".codex/rules/sauron-memory.rules",
+            "claude": ".claude/rules/sauron-base.md"
+          };
+          const relPath = rulesFileMap[target.toLowerCase().trim()];
+          if (relPath) {
+            const fullPath = path14.join(cwd, relPath);
+            if (!await fs14.pathExists(fullPath)) {
               issues.push({
                 severity: "error",
-                message: `Bloco de governan\xE7a do Sauron foi violado ou removido em: ${relPath}`,
-                file: relPath,
-                fix: `Rode sauron init para restaurar as diretrizes de compliance no arquivo do agente.`
+                message: `Configura\xE7\xE3o do agente ${target} est\xE1 ausente ou foi deletada: ${relPath}`,
+                fix: `Rode sauron init para reinjetar a integra\xE7\xE3o com o ${target}.`
               });
+            } else {
+              const rulesContent = await fs14.readFile(fullPath, "utf8");
+              if (rulesContent.trim().length === 0) {
+                issues.push({
+                  severity: "error",
+                  message: `Arquivo de governan\xE7a do Sauron est\xE1 vazio em: ${relPath}`,
+                  file: relPath,
+                  fix: `Rode sauron init para restaurar as diretrizes de compliance no arquivo do agente.`
+                });
+              }
             }
           }
         }
+      } catch (e) {
       }
     }
     const hasErrors = issues.some((issue) => issue.severity === "error");
@@ -1277,8 +1526,8 @@ import pc4 from "picocolors";
 import * as p4 from "@clack/prompts";
 
 // src/features/uninstall/uninstall.service.ts
-import fs12 from "fs-extra";
-import path12 from "path";
+import fs15 from "fs-extra";
+import path15 from "path";
 var UninstallService = class {
   registryService = new RegistryService();
   async execute(options) {
@@ -1286,25 +1535,25 @@ var UninstallService = class {
     const removedPaths = [];
     await this.registryService.unregisterWorkspace(cwd);
     removedPaths.push("~/.sauron/registry.json (descadastrado)");
-    const adapters = AdapterFactory.getAllAdapters();
+    const adapters = AdapterRegistry.getAll();
     for (const adapter of adapters) {
       const paths = await adapter.clean(cwd);
       removedPaths.push(...paths);
     }
-    const agentsMdPath = path12.join(cwd, "AGENTS.md");
-    if (await fs12.pathExists(agentsMdPath)) {
-      await fs12.remove(agentsMdPath);
+    const agentsMdPath = path15.join(cwd, "AGENTS.md");
+    if (await fs15.pathExists(agentsMdPath)) {
+      await fs15.remove(agentsMdPath);
       removedPaths.push("AGENTS.md");
     }
-    const sauronDir = path12.join(cwd, ".sauron");
-    if (await fs12.pathExists(sauronDir)) {
+    const sauronDir = path15.join(cwd, ".sauron");
+    if (await fs15.pathExists(sauronDir)) {
       if (purge) {
-        await fs12.remove(sauronDir);
+        await fs15.remove(sauronDir);
         removedPaths.push(".sauron/ (purgado por completo)");
       } else {
-        const manifestPath = path12.join(sauronDir, ".manifest.json");
-        if (await fs12.pathExists(manifestPath)) {
-          await fs12.remove(manifestPath);
+        const manifestPath = path15.join(sauronDir, ".manifest.json");
+        if (await fs15.pathExists(manifestPath)) {
+          await fs15.remove(manifestPath);
           removedPaths.push(".sauron/.manifest.json");
         }
         removedPaths.push(".sauron/wiki/ (preservado como base est\xE1tica)");