sauron-cli 1.1.3 → 1.3.0

package/dist/index.js

@@ -3,14 +3,18 @@
 // src/index.ts
 import { Command } from "commander";
 
-// src/commands/init.ts
-import fs2 from "fs-extra";
-import path2 from "path";
+// src/features/init/init.command.ts
+import fs10 from "fs-extra";
+import path10 from "path";
 import pc2 from "picocolors";
 import { fileURLToPath } from "url";
 import * as p2 from "@clack/prompts";
 
-// src/engine/manifest.ts
+// src/features/init/init.service.ts
+import fs8 from "fs-extra";
+import path8 from "path";
+
+// src/core/manifest.service.ts
 import crypto from "crypto";
 import fs from "fs-extra";
 import path from "path";
@@ -35,205 +39,1288 @@ async function saveManifest(targetDir, manifest) {
   await fs.writeJson(manifestPath, manifest, { spaces: 2 });
 }
 
-// src/engine/merge.ts
-import * as p from "@clack/prompts";
-import pc from "picocolors";
-import * as Diff from "diff";
-async function resolveConflict(filePath, localContent, newContent, manifestHash) {
+// src/core/merge.service.ts
+function checkConflict(localContent, newContent, manifestHash) {
   const localHash = generateHash(localContent);
   if (manifestHash && localHash === manifestHash) {
-    return "theirs";
+    return false;
   }
   if (localContent === newContent) {
-    return "ours";
-  }
-  p.note(`Foi detectada uma muta\xE7\xE3o no arquivo: ${pc.cyan(filePath)}
-O seu agente de IA ou voc\xEA modificou este arquivo desde a \xFAltima instala\xE7\xE3o.`, "\u26A0\uFE0F  CONFLITO DETECTADO");
-  let resolved = null;
-  while (!resolved) {
-    const action = await p.select({
-      message: `Como deseja proceder com ${pc.cyan(filePath)}?`,
-      options: [
-        { value: "ours", label: "Preservar Local (Ours)", hint: "Mant\xE9m sua vers\xE3o e ignora o novo template" },
-        { value: "theirs", label: "Sobrescrever (Theirs)", hint: "Destr\xF3i a sua vers\xE3o e aplica o template novo" },
-        { value: "diff", label: "Auditar Diferen\xE7as (Diff Mode)", hint: "Mostra o que vai mudar visualmente" }
-      ]
-    });
-    if (p.isCancel(action)) {
-      p.cancel("Opera\xE7\xE3o cancelada pelo usu\xE1rio durante a resolu\xE7\xE3o de conflito.");
-      process.exit(0);
+    return false;
+  }
+  return true;
+}
+
+// src/features/init/templates.ts
+function generateAgentsMarkdown(aiTargets, severity, projectContext, projectStack) {
+  return `# Diretrizes Globais de Agentes (Sauron CLI)
+
+**Alvos:** ${aiTargets.join(", ")}
+**Severidade:** ${severity}
+
+## Contexto do Projeto
+${projectContext}
+
+## Stack Tecnol\xF3gica
+${projectStack}
+
+## Regra de Ouro (Write Obligation)
+Todos os agentes operando neste reposit\xF3rio est\xE3o estritamente obrigados a documentar qualquer altera\xE7\xE3o arquitetural, de regra de neg\xF3cio ou muta\xE7\xE3o de estado nas pastas \`.sauron\` e \`.agents\` correspondentes. A leitura passiva sem documenta\xE7\xE3o \xE9 considerada quebra de compliance.
+
+*Gerado automaticamente pelo Sauron CLI.*
+`;
+}
+
+// src/core/registry/registry.service.ts
+import fs2 from "fs-extra";
+import path2 from "path";
+import os from "os";
+var RegistryService = class {
+  getRegistryPath() {
+    const homeDir = os.homedir();
+    return path2.join(homeDir, ".sauron", "registry.json");
+  }
+  async registerWorkspace(name, rootPath, aiTargets, severity) {
+    const registryPath = this.getRegistryPath();
+    await fs2.ensureDir(path2.dirname(registryPath));
+    let workspaces = [];
+    if (await fs2.pathExists(registryPath)) {
+      try {
+        workspaces = await fs2.readJson(registryPath);
+      } catch (err) {
+        workspaces = [];
+      }
     }
-    if (action === "diff") {
-      const diffStr = renderDiff(localContent, newContent, filePath);
-      console.log("\n" + diffStr + "\n");
+    const normalizedPath = path2.resolve(rootPath).replace(/\\/g, "/");
+    const existingIndex = workspaces.findIndex(
+      (w) => path2.resolve(w.rootPath).replace(/\\/g, "/") === normalizedPath
+    );
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    if (existingIndex >= 0) {
+      workspaces[existingIndex] = {
+        ...workspaces[existingIndex],
+        name,
+        aiTargets,
+        severity,
+        lastCheckedAt: now
+      };
     } else {
-      resolved = action;
+      workspaces.push({
+        name,
+        rootPath: normalizedPath,
+        initializedAt: now,
+        lastCheckedAt: now,
+        aiTargets,
+        severity
+      });
     }
+    await fs2.writeJson(registryPath, workspaces, { spaces: 2 });
   }
-  return resolved;
-}
-function renderDiff(oldStr, newStr, fileName) {
-  const diffs = Diff.diffLines(oldStr, newStr);
-  let output = pc.bold(`--- a/${fileName} (Local)
+  async unregisterWorkspace(rootPath) {
+    const registryPath = this.getRegistryPath();
+    if (!await fs2.pathExists(registryPath)) {
+      return;
+    }
+    let workspaces = [];
+    try {
+      workspaces = await fs2.readJson(registryPath);
+    } catch (err) {
+      return;
+    }
+    const normalizedPath = path2.resolve(rootPath).replace(/\\/g, "/");
+    const filtered = workspaces.filter(
+      (w) => path2.resolve(w.rootPath).replace(/\\/g, "/") !== normalizedPath
+    );
+    await fs2.writeJson(registryPath, filtered, { spaces: 2 });
+  }
+  async listWorkspaces() {
+    const registryPath = this.getRegistryPath();
+    if (!await fs2.pathExists(registryPath)) {
+      return [];
+    }
+    try {
+      return await fs2.readJson(registryPath);
+    } catch (err) {
+      return [];
+    }
+  }
+};
+
+// src/core/adapters/cursor.adapter.ts
+import fs3 from "fs-extra";
+import path3 from "path";
+var CursorAdapter = class {
+  getName() {
+    return "Cursor";
+  }
+  async inject(cwd, rulesContent) {
+    const rulesDir = path3.join(cwd, ".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: *
+---
+
+# SAURON START
+${rulesContent}
+# 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");
+    if (await fs3.pathExists(mdcPath)) {
+      await fs3.remove(mdcPath);
+      return [".cursor/rules/sauron-memory.mdc"];
+    }
+    return [];
+  }
+};
+
+// src/core/adapters/windsurf.adapter.ts
+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
+`;
+    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 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 [".windsurfrules"];
+  }
+  removeSauronBlock(content) {
+    const regex = /# SAURON START[\s\S]*?# SAURON END/g;
+    return content.replace(regex, "").trim();
+  }
+};
+
+// src/core/adapters/aider.adapter.ts
+import fs5 from "fs-extra";
+import path5 from "path";
+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"];
+    }
+    return [];
+  }
+};
+
+// src/core/adapters/antigravity.adapter.ts
+import fs6 from "fs-extra";
+import path6 from "path";
+var AntigravityAdapter = class {
+  getName() {
+    return "Antigravity";
+  }
+  async inject(cwd, rulesContent) {
+    const rulesPath = path6.join(cwd, ".agents", "rules", "memory.md");
+    await fs6.ensureDir(path6.dirname(rulesPath));
+    const content = `---
+trigger: always_on
+---
+
+# SAURON START
+${rulesContent}
+# SAURON END
+`;
+    await fs6.writeFile(rulesPath, content, "utf8");
+    return [".agents/rules/memory.md"];
+  }
+  async clean(cwd) {
+    const agentsDir = path6.join(cwd, ".agents");
+    if (await fs6.pathExists(agentsDir)) {
+      await fs6.remove(agentsDir);
+      return [".agents/rules/memory.md", ".agents/skills/wiki/SKILL.md"];
+    }
+    return [];
+  }
+};
+
+// 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;
+    }
+  }
+  static getAllAdapters() {
+    return [
+      new CursorAdapter(),
+      new WindsurfAdapter(),
+      new AiderAdapter(),
+      new AntigravityAdapter()
+    ];
+  }
+};
+
+// src/core/wiki/wiki-bootstrapper.ts
+import fs7 from "fs-extra";
+import path7 from "path";
+var WikiBootstrapper = class {
+  constructor(projectRoot) {
+    this.projectRoot = projectRoot;
+    this.wikiDir = path7.join(projectRoot, ".sauron", "wiki");
+    this.standardsDir = path7.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)) {
+      return [];
+    }
+    await fs7.ensureDir(this.standardsDir);
+    const summaryPath = path7.join(this.wikiDir, "summary.json");
+    let summary = [];
+    if (await fs7.pathExists(summaryPath)) {
+      try {
+        summary = await fs7.readJson(summaryPath);
+      } catch (err) {
+        summary = [];
+      }
+    }
+    for (const templateName of wikiTemplatesToInject) {
+      const srcTemplatePath = path7.join(recipesSrcDir, templateName);
+      if (!await fs7.pathExists(srcTemplatePath)) {
+        continue;
+      }
+      const destFilename = templateName;
+      const destFullPath = path7.join(this.standardsDir, destFilename);
+      const relWikiPath = `standards/${destFilename}`;
+      const content = await fs7.readFile(srcTemplatePath, "utf8");
+      const hash = generateHash(content);
+      const len = Buffer.byteLength(content, "utf8");
+      const exists = await fs7.pathExists(destFullPath);
+      if (!exists) {
+        await fs7.writeFile(destFullPath, content, "utf8");
+        injectedFiles.push(path7.join(".sauron", "wiki", relWikiPath).replace(/\\/g, "/"));
+      }
+      const slug = destFilename.replace(".rules.md", "").replace(".rules.txt", "");
+      const docName = this.inferDocName(slug);
+      const kbId = `kb-standards-${slug}`;
+      const existingIndex = summary.findIndex((item) => item.path === relWikiPath);
+      const newItem = {
+        type: "file",
+        name: docName,
+        slug: `${slug}-rules`,
+        path: relWikiPath,
+        id: kbId,
+        domainId: "domain-standards",
+        orgId: "org-sauron-cli",
+        contentLength: len,
+        contentHash: hash
+      };
+      if (existingIndex >= 0) {
+        summary[existingIndex] = {
+          ...summary[existingIndex],
+          contentLength: len,
+          contentHash: hash
+        };
+      } else {
+        summary.push(newItem);
+      }
+    }
+    await fs7.writeJson(summaryPath, summary, { spaces: 2 });
+    return injectedFiles;
+  }
+  inferDocName(slug) {
+    switch (slug.toLowerCase()) {
+      case "typescript":
+        return "TypeScript Guidelines";
+      case "nextjs":
+        return "Next.js App Router Rules";
+      case "react":
+        return "React Components & Hooks";
+      case "postgresql":
+        return "PostgreSQL SQL Standards";
+      case "tailwindcss":
+        return "Tailwind CSS Styles Manual";
+      default:
+        return `${slug.charAt(0).toUpperCase() + slug.slice(1)} Standards`;
+    }
+  }
+};
+
+// src/features/init/init.service.ts
+var InitService = class {
+  registryService = new RegistryService();
+  async execute(options, driver) {
+    const { cwd, templatesDir } = options;
+    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);
+      for (const file of files) {
+        const sourcePath = path8.join(source, file);
+        const targetPath = path8.join(target, file);
+        const stat = await fs8.stat(sourcePath);
+        if (stat.isDirectory()) {
+          await fs8.ensureDir(targetPath);
+          await processDirectory(sourcePath, targetPath);
+        } else {
+          const content = await fs8.readFile(sourcePath, "utf8");
+          const relPath = path8.relative(cwd, targetPath).replace(/\\/g, "/");
+          let shouldWrite = true;
+          if (await fs8.pathExists(targetPath)) {
+            const localContent = await fs8.readFile(targetPath, "utf8");
+            const hasConflict = checkConflict(localContent, content, manifest.files[relPath]);
+            if (hasConflict) {
+              const decision = await driver.resolveConflict(relPath, localContent, content);
+              if (decision === "ours") {
+                shouldWrite = false;
+              }
+            }
+          } else {
+            await fs8.ensureDir(path8.dirname(targetPath));
+          }
+          if (shouldWrite) {
+            await fs8.writeFile(targetPath, content, "utf8");
+            modifiedFiles.push(relPath);
+          }
+          const isMutable = relPath.startsWith(".sauron/wiki/") || relPath === ".agents/rules/memory.md";
+          if (!isMutable) {
+            manifest.files[relPath] = generateHash(content);
+          }
+        }
+      }
+    };
+    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");
+    const agentsMdContent = generateAgentsMarkdown(
+      options.aiTargets,
+      options.severity,
+      options.projectContext,
+      options.projectStack
+    );
+    let shouldWriteAgents = true;
+    if (await fs8.pathExists(agentsMdPath)) {
+      const localAgents = await fs8.readFile(agentsMdPath, "utf8");
+      const hasConflict = checkConflict(localAgents, agentsMdContent, manifest.files["AGENTS.md"]);
+      if (hasConflict) {
+        const decision = await driver.resolveConflict("AGENTS.md", localAgents, agentsMdContent);
+        if (decision === "ours") {
+          shouldWriteAgents = false;
+        }
+      }
+    }
+    if (shouldWriteAgents) {
+      await fs8.writeFile(agentsMdPath, agentsMdContent, "utf8");
+      modifiedFiles.push("AGENTS.md");
+    }
+    manifest.files["AGENTS.md"] = generateHash(agentsMdContent);
+    await saveManifest(cwd, manifest);
+    modifiedFiles.push(".sauron/.manifest.json");
+    const memoryFilePath = path8.join(cwd, ".agents", "rules", "memory.md");
+    let memoryRulesContent = "";
+    if (await fs8.pathExists(memoryFilePath)) {
+      memoryRulesContent = await fs8.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);
+        modifiedFiles.push(...paths);
+      }
+    }
+    const bootstrapper = new WikiBootstrapper(cwd);
+    const injectedWikiFiles = await bootstrapper.bootstrapFromTemplates(
+      templatesDir,
+      options.wikiTemplatesToInject
+    );
+    modifiedFiles.push(...injectedWikiFiles);
+    const projectName = path8.basename(cwd) || "Unnamed Project";
+    await this.registryService.registerWorkspace(
+      projectName,
+      cwd,
+      options.aiTargets,
+      options.severity
+    );
+    return modifiedFiles;
+  }
+};
+
+// src/domain/session/session-context.ts
+var SessionContext = class {
+  json;
+  interactive;
+  conflictResolution;
+  yes;
+  constructor(options) {
+    this.json = options.json;
+    this.yes = options.yes || false;
+    this.interactive = options.json ? false : options.interactive ?? true;
+    this.conflictResolution = options.conflictResolution;
+  }
+};
+
+// src/presentation/drivers/terminal.driver.ts
+import * as p from "@clack/prompts";
+import pc from "picocolors";
+import * as Diff from "diff";
+var TerminalDriver = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  spinnerInstance = p.spinner();
+  logInfo(msg) {
+    console.log(pc.blue("\u2139 ") + pc.white(msg));
+  }
+  logWarning(msg) {
+    console.log(pc.yellow("\u26A0\uFE0F ") + pc.yellow(msg));
+  }
+  logSuccess(msg) {
+    console.log(pc.green("\u2714 ") + pc.green(msg));
+  }
+  logError(msg) {
+    console.log(pc.red("\u2716 ") + pc.red(msg));
+  }
+  startSpinner(msg) {
+    this.spinnerInstance.start(msg);
+  }
+  stopSpinner(msg, success = true) {
+    if (success) {
+      this.spinnerInstance.stop(pc.green("\u2714 ") + msg);
+    } else {
+      this.spinnerInstance.stop(pc.red("\u2716 ") + msg);
+    }
+  }
+  async resolveConflict(filePath, localContent, newContent) {
+    this.stopSpinner(`Conflito em ${filePath}`, false);
+    if (!this.context.interactive) {
+      if (this.context.conflictResolution) {
+        this.logInfo(
+          `Conflito em ${filePath} resolvido automaticamente como '${this.context.conflictResolution}' em execu\xE7\xE3o n\xE3o-interativa.`
+        );
+        this.startSpinner("Continuando processamento...");
+        return this.context.conflictResolution;
+      }
+      this.logError(
+        `Conflito detectado em ${filePath} em execu\xE7\xE3o n\xE3o-interativa sem flag de resolu\xE7\xE3o configurada (--conflict).`
+      );
+      this.finish({
+        success: false,
+        message: `Conflito n\xE3o resolvido no arquivo ${filePath}. Defina --conflict para automatizar a resolu\xE7\xE3o.`
+      });
+      process.exit(1);
+    }
+    p.note(
+      `Foi detectada uma muta\xE7\xE3o no arquivo: ${pc.cyan(filePath)}
+O seu agente de IA ou voc\xEA modificou este arquivo desde a \xFAltima instala\xE7\xE3o.`,
+      "\u26A0\uFE0F  CONFLITO DETECTADO"
+    );
+    let resolved = null;
+    while (!resolved) {
+      const action = await p.select({
+        message: `Como deseja proceder com ${pc.cyan(filePath)}?`,
+        options: [
+          { value: "ours", label: "Preservar Local (Ours)", hint: "Mant\xE9m sua vers\xE3o e ignora o novo template" },
+          { value: "theirs", label: "Sobrescrever (Theirs)", hint: "Destr\xF3i a sua vers\xE3o e aplica o template novo" },
+          { value: "diff", label: "Auditar Diferen\xE7as (Diff Mode)", hint: "Mostra o que vai mudar visualmente" }
+        ]
+      });
+      if (p.isCancel(action)) {
+        p.cancel("Opera\xE7\xE3o cancelada pelo usu\xE1rio durante a resolu\xE7\xE3o de conflito.");
+        process.exit(0);
+      }
+      if (action === "diff") {
+        const diffStr = this.renderDiff(localContent, newContent, filePath);
+        console.log("\n" + diffStr + "\n");
+      } else {
+        resolved = action;
+      }
+    }
+    this.startSpinner("Continuando processamento...");
+    return resolved;
+  }
+  finish(data) {
+    if (data.success) {
+      p.outro(pc.green(pc.bold(data.message || "Opera\xE7\xE3o finalizada com sucesso!")));
+    } else {
+      p.cancel(pc.red(pc.bold(data.message || "Opera\xE7\xE3o falhou.")));
+      process.exit(1);
+    }
+  }
+  renderDiff(oldStr, newStr, fileName) {
+    const diffs = Diff.diffLines(oldStr, newStr);
+    let output = pc.bold(`--- a/${fileName} (Local)
 +++ b/${fileName} (Novo Template)
 `);
-  diffs.forEach((part) => {
-    const lines = part.value.replace(/\n$/, "").split("\n");
-    for (const line of lines) {
-      if (part.added) {
-        output += pc.green(`+ ${line}
+    diffs.forEach((part) => {
+      const lines = part.value.replace(/\n$/, "").split("\n");
+      for (const line of lines) {
+        if (part.added) {
+          output += pc.green(`+ ${line}
 `);
-      } else if (part.removed) {
-        output += pc.red(`- ${line}
+        } else if (part.removed) {
+          output += pc.red(`- ${line}
 `);
-      } else {
-        output += pc.dim(`  ${line}
+        } else {
+          output += pc.dim(`  ${line}
 `);
+        }
       }
+    });
+    return output;
+  }
+};
+
+// src/presentation/drivers/json.driver.ts
+var JsonDriver = class {
+  constructor(context) {
+    this.context = context;
+  }
+  context;
+  logs = [];
+  payload = null;
+  logInfo(msg) {
+    this.addLog("info", msg);
+  }
+  logWarning(msg) {
+    this.addLog("warning", msg);
+  }
+  logSuccess(msg) {
+    this.addLog("success", msg);
+  }
+  logError(msg) {
+    this.addLog("error", msg);
+  }
+  startSpinner(msg) {
+    this.addLog("info", `Come\xE7ou: ${msg}`);
+  }
+  stopSpinner(msg, success = true) {
+    this.addLog(success ? "success" : "error", `Terminou: ${msg}`);
+  }
+  async resolveConflict(filePath, localContent, newContent) {
+    this.addLog("warning", `Conflito detectado no arquivo: ${filePath}`);
+    if (this.context.conflictResolution) {
+      this.addLog(
+        "info",
+        `Conflito em ${filePath} resolvido automaticamente como '${this.context.conflictResolution}' via configura\xE7\xE3o de sess\xE3o.`
+      );
+      return this.context.conflictResolution;
     }
-  });
-  return output;
-}
+    this.addLog(
+      "error",
+      `Bloqueio de execu\xE7\xE3o: Conflito detectado em ${filePath} em execu\xE7\xE3o program\xE1tica/n\xE3o-interativa sem flag de resolu\xE7\xE3o configurada (--conflict).`
+    );
+    this.finish({
+      success: false,
+      message: `Conflito n\xE3o resolvido no arquivo ${filePath}. Defina --conflict para automatizar a resolu\xE7\xE3o.`
+    });
+    process.exit(1);
+  }
+  finish(data) {
+    const output = {
+      success: data.success,
+      message: data.message || (data.success ? "Opera\xE7\xE3o conclu\xEDda" : "Opera\xE7\xE3o falhou"),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      logs: this.logs,
+      payload: data.payload || this.payload
+    };
+    console.log(JSON.stringify(output, null, 2));
+    if (!data.success) {
+      process.exit(1);
+    }
+  }
+  addLog(level, message) {
+    this.logs.push({
+      level,
+      message,
+      timestamp: (/* @__PURE__ */ new Date()).toISOString()
+    });
+  }
+};
 
-// src/commands/init.ts
+// src/presentation/router.ts
+var PresentationRouter = class {
+  static createDriver(context) {
+    if (context.json) {
+      return new JsonDriver(context);
+    }
+    return new TerminalDriver(context);
+  }
+};
+
+// src/core/scanner/project-scanner.ts
+import fs9 from "fs-extra";
+import path9 from "path";
+
+// src/core/scanner/signatures.ts
+var TECHNOLOGY_SIGNATURES = [
+  {
+    name: "TypeScript",
+    deps: ["typescript", "@types/node"],
+    files: ["tsconfig.json"],
+    wikiTemplate: "typescript.rules.md"
+  },
+  {
+    name: "Next.js",
+    deps: ["next"],
+    files: ["next.config.js", "next.config.mjs"],
+    wikiTemplate: "nextjs.rules.md"
+  },
+  {
+    name: "React",
+    deps: ["react", "react-dom"],
+    wikiTemplate: "react.rules.md"
+  },
+  {
+    name: "NestJS",
+    deps: ["@nestjs/core", "@nestjs/common"],
+    files: ["nest-cli.json"]
+  },
+  {
+    name: "Express",
+    deps: ["express", "@types/express"]
+  },
+  {
+    name: "Prisma ORM",
+    deps: ["prisma", "@prisma/client"],
+    files: ["prisma/schema.prisma"]
+  },
+  {
+    name: "PostgreSQL",
+    deps: ["pg"],
+    regex: {
+      file: "compose.yml",
+      pattern: /image:\s*postgres/i
+    },
+    wikiTemplate: "postgresql.rules.md"
+  },
+  {
+    name: "PostgreSQL (Docker-Compose)",
+    regex: {
+      file: "docker-compose.yml",
+      pattern: /image:\s*postgres/i
+    },
+    wikiTemplate: "postgresql.rules.md"
+  },
+  {
+    name: "Tailwind CSS",
+    deps: ["tailwindcss"],
+    files: ["tailwind.config.js", "tailwind.config.ts", "postcss.config.js"],
+    wikiTemplate: "tailwindcss.rules.md"
+  },
+  {
+    name: "Redis",
+    regex: {
+      file: "compose.yml",
+      pattern: /image:\s*redis/i
+    }
+  },
+  {
+    name: "Redis (Docker-Compose)",
+    regex: {
+      file: "docker-compose.yml",
+      pattern: /image:\s*redis/i
+    }
+  }
+];
+
+// src/core/scanner/project-scanner.ts
+var ProjectScanner = class {
+  cwd;
+  constructor(cwd = process.cwd()) {
+    this.cwd = cwd;
+  }
+  async scan() {
+    const context = {
+      primaryLanguage: "JavaScript",
+      // Fallback padrão
+      frameworks: [],
+      database: [],
+      styling: [],
+      packageManager: "npm",
+      isMonorepo: false,
+      detectedIAs: [],
+      wikiTemplatesToInject: []
+    };
+    try {
+      const rootEntries = await fs9.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")) {
+        context.packageManager = "pnpm";
+        if (rootFiles.includes("pnpm-workspace.yaml")) {
+          context.isMonorepo = true;
+        }
+      } else if (rootFiles.includes("yarn.lock")) {
+        context.packageManager = "yarn";
+      } else if (rootFiles.includes("package-lock.json")) {
+        context.packageManager = "npm";
+      }
+      if (rootFiles.includes("tsconfig.json")) {
+        context.primaryLanguage = "TypeScript";
+      }
+      if (rootDirs.includes(".cursor") || rootFiles.includes(".cursorrules")) {
+        context.detectedIAs.push("Cursor");
+      }
+      if (rootFiles.includes(".windsurfrules")) {
+        context.detectedIAs.push("Windsurf");
+      }
+      if (rootFiles.includes(".aider.instructions.md") || rootFiles.includes(".aider.conf.yml")) {
+        context.detectedIAs.push("Aider");
+      }
+      if (rootDirs.includes(".agents")) {
+        context.detectedIAs.push("Antigravity");
+      }
+      if (context.detectedIAs.length === 0) {
+        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 allDeps = {
+          ...pkg.dependencies || {},
+          ...pkg.devDependencies || {}
+        };
+        for (const sig of TECHNOLOGY_SIGNATURES) {
+          let matched = false;
+          if (sig.deps && sig.deps.some((dep) => allDeps[dep])) {
+            matched = true;
+          }
+          if (sig.files && sig.files.some((f) => rootFiles.includes(f) || rootDirs.includes(f))) {
+            matched = true;
+          }
+          if (matched) {
+            this.categorizeAndAdd(sig, context);
+          }
+        }
+      }
+      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");
+          for (const sig of TECHNOLOGY_SIGNATURES) {
+            if (sig.regex && sig.regex.file === composeFile) {
+              if (sig.regex.pattern.test(composeContent)) {
+                this.categorizeAndAdd(sig, context);
+              }
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.warn("O Scanner de Arquitetura do Sauron encontrou um atrito de I/O n\xE3o-fatal: ", error);
+    }
+    return context;
+  }
+  categorizeAndAdd(sig, context) {
+    const name = sig.name;
+    if (name.toLowerCase().includes("tailwind") || name.toLowerCase().includes("styled")) {
+      if (!context.styling.includes(name)) context.styling.push(name);
+    } else if (name.toLowerCase().includes("postgres") || name.toLowerCase().includes("prisma") || name.toLowerCase().includes("redis") || name.toLowerCase().includes("mongo")) {
+      if (!context.database.includes(name)) context.database.push(name);
+    } else {
+      if (name !== "TypeScript" && !context.frameworks.includes(name)) {
+        context.frameworks.push(name);
+      }
+    }
+    if (sig.wikiTemplate && !context.wikiTemplatesToInject.includes(sig.wikiTemplate)) {
+      context.wikiTemplatesToInject.push(sig.wikiTemplate);
+    }
+  }
+};
+
+// src/features/init/init.command.ts
 var __filename = fileURLToPath(import.meta.url);
-var __dirname = path2.dirname(__filename);
-async function runInit(options) {
+var __dirname = path10.dirname(__filename);
+async function runInitCommand(options) {
   const cwd = process.cwd();
-  const logo = `
+  const session = new SessionContext({
+    json: !!options.json,
+    interactive: !options.yes && !options.json,
+    conflictResolution: options.conflict,
+    yes: options.yes
+  });
+  const driver = PresentationRouter.createDriver(session);
+  const scanner = new ProjectScanner(cwd);
+  let scanSpinner = null;
+  if (!session.json) {
+    scanSpinner = p2.spinner();
+    scanSpinner.start("O Olho de Sauron est\xE1 varrendo o reposit\xF3rio em busca da stack tecnol\xF3gica e depend\xEAncias...");
+  }
+  const scannedContext = await scanner.scan();
+  if (session.interactive) {
+    await new Promise((resolve) => setTimeout(resolve, 800));
+  }
+  if (scanSpinner) {
+    scanSpinner.stop("Mapeamento neural conclu\xEDdo com sucesso. Contexto do reposit\xF3rio foi inferido.");
+  }
+  if (!session.json) {
+    const logo = `
 \x1B[38;2;255;106;0m \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588  \u2588\u2588    \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588\u2588    \u2588\u2588\x1B[0m
 \x1B[38;2;255;179;0m\u2588\u2588      \u2588\u2588   \u2588\u2588 \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588\u2588\u2588   \u2588\u2588\x1B[0m
 \x1B[38;2;255;215;0m\u255A\u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588 \u2588\u2588    \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588 \u2588\u2588 \u2588\u2588  \u2588\u2588\x1B[0m
-\x1B[38;2;255;140;0m     \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588  \u2588\u2588 \u2588\u2588\x1B[0m
+\x1B[38;2;255;140;0m     \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588    \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588   \u2588\u2588 \u2588\u2588  \u2588\u2588 \u2588\u2588
 \x1B[38;2;204;51;0m\u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588  \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588 \u2588\u2588\u2588\u2588\u2588\u2588  \u2588\u2588   \u2588\u2588\u2588\u2588\x1B[0m
 `;
-  console.log(pc2.bold(logo));
-  console.log(pc2.dim("  CLI de Idempot\xEAncia e Mem\xF3ria para IAs\n"));
-  p2.intro(pc2.bgRed(pc2.white(" Sauron Memory System - Inicializa\xE7\xE3o ")));
-  let aiTargets = ["Cursor", "Windsurf", "Aider", "Antigravity"];
+    console.log(pc2.bold(logo));
+    console.log(pc2.dim("  CLI de Idempot\xEAncia e Mem\xF3ria para IAs\n"));
+    p2.intro(pc2.bgRed(pc2.white(" Sauron Memory System - Inicializa\xE7\xE3o ")));
+  }
+  let aiTargets = scannedContext.detectedIAs;
   let severity = "Observacional";
   let projectContext = "Projeto Gen\xE9rico";
-  let projectStack = "Node.js, TypeScript";
-  if (!options.yes) {
-    const config = await p2.group(
+  const inferredStackString = [
+    scannedContext.primaryLanguage,
+    ...scannedContext.frameworks,
+    ...scannedContext.database,
+    ...scannedContext.styling
+  ].filter(Boolean).join(", ");
+  let projectStack = inferredStackString || "Node.js, TypeScript";
+  if (session.interactive) {
+    try {
+      const config = await p2.group(
+        {
+          targets: () => p2.multiselect({
+            message: "Confirmar a(s) IA(s) operativas que consumir\xE3o ativamente o contexto estruturado da Wiki:",
+            options: [
+              { value: "Cursor", label: "Cursor", hint: "Recomendado" },
+              { value: "Windsurf", label: "Windsurf" },
+              { value: "Aider", label: "Aider" },
+              { value: "Antigravity", label: "Antigravity", hint: "Agente nativo" }
+            ],
+            initialValues: aiTargets,
+            required: false
+          }),
+          severity: () => p2.select({
+            message: "Defina a severidade rigorosa de implementa\xE7\xE3o das regras contextuais da IA:",
+            options: [
+              { value: "Observacional", label: "Observacional (As regras servem apenas de sugest\xF5es org\xE2nicas)" },
+              { value: "Estrito", label: "Estrito (Enforcement ativo e recusa de l\xF3gicas em desacordo)" }
+            ],
+            initialValue: severity
+          }),
+          context: () => p2.text({
+            message: "Descreva brevemente o contexto sist\xEAmico do projeto (ou ratifique o contexto preditivo):",
+            placeholder: "Ex: App de agendamento de pilates",
+            initialValue: projectContext
+          }),
+          stack: () => p2.text({
+            message: "Qual a stack tecnol\xF3gica mapeada em definitivo para este projeto?",
+            placeholder: "Ex: Next.js 15, Tailwind, Firebase",
+            initialValue: projectStack
+          })
+        },
+        {
+          onCancel: () => {
+            p2.cancel("Inicializa\xE7\xE3o abortada.");
+            process.exit(0);
+          }
+        }
+      );
+      aiTargets = config.targets;
+      severity = config.severity;
+      projectContext = config.context;
+      projectStack = config.stack;
+    } catch (error) {
+      driver.finish({ success: false, message: `Erro ao interagir com console: ${error.message}` });
+      return;
+    }
+  }
+  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");
+  }
+  const initService = new InitService();
+  try {
+    const modifiedFiles = await initService.execute(
       {
-        targets: () => p2.multiselect({
-          message: "Qual(is) IA(s) voc\xEA usar\xE1 neste projeto?",
-          options: [
-            { value: "Cursor", label: "Cursor", hint: "Recomendado" },
-            { value: "Windsurf", label: "Windsurf" },
-            { value: "Aider", label: "Aider" },
-            { value: "Antigravity", label: "Antigravity", hint: "Agente nativo" }
-          ],
-          required: false
-        }),
-        severity: () => p2.select({
-          message: "Qual o n\xEDvel de severidade das regras da IA?",
-          options: [
-            { value: "Observacional", label: "Observacional (A IA documenta quando julgar necess\xE1rio)" },
-            { value: "Estrito", label: "Estrito (Bloqueia altera\xE7\xF5es sem documenta\xE7\xE3o expl\xEDcita)" }
-          ]
-        }),
-        context: () => p2.text({
-          message: "Descreva brevemente o contexto do seu projeto:",
-          placeholder: "Ex: App de agendamento de pilates",
-          defaultValue: "Projeto Gen\xE9rico"
-        }),
-        stack: () => p2.text({
-          message: "Qual a stack tecnol\xF3gica principal do seu projeto?",
-          placeholder: "Ex: Next.js 15, Tailwind, Firebase",
-          defaultValue: "Node.js, TypeScript"
-        })
+        aiTargets,
+        severity,
+        projectContext,
+        projectStack,
+        cwd,
+        templatesDir,
+        wikiTemplatesToInject: scannedContext.wikiTemplatesToInject
       },
-      {
-        onCancel: () => {
-          p2.cancel("Inicializa\xE7\xE3o abortada.");
-          process.exit(0);
-        }
+      driver
+    );
+    driver.stopSpinner("Inje\xE7\xE3o finalizada.", true);
+    const message = 'Sauron Memory System instalado com sucesso!\n\nO C\xE9rebro da IA foi injetado e protegido pelo motor de integridade.\nA\xE7\xF5es Recomendadas:\nCopie o comando abaixo e envie para a sua IA testar a nova arquitetura:\n"Analise a estrutura .sauron/ e .agents/ rec\xE9m injetada e sugira quais regras cr\xEDticas eu devo documentar agora para nosso projeto."';
+    driver.finish({
+      success: true,
+      message,
+      payload: {
+        projectName: path10.basename(cwd),
+        cwd,
+        aiTargets,
+        severity,
+        modifiedFiles
       }
+    });
+  } catch (error) {
+    driver.stopSpinner("Falha na instala\xE7\xE3o.", false);
+    driver.finish({ success: false, message: error.message });
+  }
+}
+
+// src/features/doctor/doctor.command.ts
+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";
+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 registered = workspaces.find(
+      (w) => path11.resolve(w.rootPath).replace(/\\/g, "/") === normalizedCwd
     );
-    aiTargets = config.targets;
-    severity = config.severity;
-    projectContext = config.context;
-    projectStack = config.stack;
-  }
-  const s = p2.spinner();
-  s.start("Injetando o C\xE9rebro da IA no reposit\xF3rio...");
-  const packageRoot = path2.join(__dirname, "..", "..");
-  const templatesDir = path2.join(packageRoot, "templates");
-  const manifest = await getManifest(cwd) || { version: "1.0.0", files: {} };
-  async function processDirectory(source, target) {
-    if (!await fs2.pathExists(source)) return;
-    const files = await fs2.readdir(source);
-    for (const file of files) {
-      const sourcePath = path2.join(source, file);
-      const targetPath = path2.join(target, file);
-      const stat = await fs2.stat(sourcePath);
-      if (stat.isDirectory()) {
-        await fs2.ensureDir(targetPath);
-        await processDirectory(sourcePath, targetPath);
-      } else {
-        const content = await fs2.readFile(sourcePath, "utf8");
-        const relPath = path2.relative(cwd, targetPath).replace(/\\/g, "/");
-        let shouldWrite = true;
-        if (await fs2.pathExists(targetPath)) {
-          const localContent = await fs2.readFile(targetPath, "utf8");
-          s.stop(`Conflito ou atualiza\xE7\xE3o em ${relPath}`);
-          const decision = await resolveConflict(relPath, localContent, content, manifest.files[relPath]);
-          s.start("Continuando inje\xE7\xE3o...");
-          if (decision === "ours") {
-            shouldWrite = false;
+    if (!registered) {
+      issues.push({
+        severity: "warning",
+        message: "Este projeto n\xE3o est\xE1 cadastrado no registro central do Sauron na m\xE1quina.",
+        fix: 'Execute "sauron init" para registrar o projeto globalmente.'
+      });
+    }
+    const manifest = await getManifest(cwd);
+    if (!manifest) {
+      issues.push({
+        severity: "error",
+        message: "Manifesto do Sauron (.sauron/.manifest.json) n\xE3o foi encontrado.",
+        fix: 'Execute "sauron init -y" para reinjetar a estrutura de manifesto.'
+      });
+    } else {
+      for (const [relPath, expectedHash] of Object.entries(manifest.files)) {
+        const fullPath = path11.join(cwd, relPath);
+        if (!await fs11.pathExists(fullPath)) {
+          issues.push({
+            severity: "error",
+            message: `Arquivo gerenciado pelo manifesto est\xE1 ausente: ${relPath}`,
+            file: relPath,
+            fix: 'Execute "sauron init" para restaurar os arquivos originais.'
+          });
+          continue;
+        }
+        const fileContent = await fs11.readFile(fullPath, "utf8");
+        const computedHash = generateHash(fileContent);
+        if (computedHash !== expectedHash) {
+          issues.push({
+            severity: "warning",
+            message: `Modifica\xE7\xE3o manual detectada no arquivo do sistema: ${relPath}`,
+            file: relPath,
+            fix: "Valide se a modifica\xE7\xE3o foi intencional ou execute sauron init para restaurar o padr\xE3o."
+          });
+        }
+      }
+    }
+    const summaryPath = path11.join(cwd, ".sauron", "wiki", "summary.json");
+    if (!await fs11.pathExists(summaryPath)) {
+      issues.push({
+        severity: "error",
+        message: "Arquivo de sum\xE1rio da wiki (.sauron/wiki/summary.json) est\xE1 ausente.",
+        fix: 'Execute "sauron init" para restabelecer os diret\xF3rios base da wiki.'
+      });
+    } else {
+      try {
+        const summary = await fs11.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)) {
+                issues.push({
+                  severity: "error",
+                  message: `Documento catalogado no sum\xE1rio est\xE1 ausente: ${fileRelPath}`,
+                  file: fileRelPath,
+                  fix: `Recrie o arquivo correspondente ou remova-o de summary.json.`
+                });
+                continue;
+              }
+              const content = await fs11.readFile(fileFullPath, "utf8");
+              const computedHash = generateHash(content);
+              const computedLen = Buffer.byteLength(content, "utf8");
+              if (item.contentHash && computedHash !== item.contentHash) {
+                issues.push({
+                  severity: "warning",
+                  message: `Diverg\xEAncia de assinatura criptogr\xE1fica no documento da wiki: ${fileRelPath}`,
+                  file: fileRelPath,
+                  fix: `Atualize o summary.json com o novo hash: "${computedHash}" e tamanho: ${computedLen}.`
+                });
+              }
+              if (item.contentLength !== void 0 && computedLen !== item.contentLength) {
+                issues.push({
+                  severity: "warning",
+                  message: `Diverg\xEAncia de tamanho de conte\xFAdo (bytes) no documento: ${fileRelPath}`,
+                  file: fileRelPath,
+                  fix: `Atualize o summary.json com o novo tamanho em bytes: ${computedLen}.`
+                });
+              }
+            }
           }
         } else {
-          await fs2.ensureDir(path2.dirname(targetPath));
+          issues.push({
+            severity: "error",
+            message: "summary.json possui formato estrutural inv\xE1lido (deve ser um array de objetos).",
+            fix: "Corrija a formata\xE7\xE3o do JSON para seguir o padr\xE3o do Sauron CLI."
+          });
         }
-        if (shouldWrite) {
-          await fs2.writeFile(targetPath, content, "utf8");
+      } catch (err) {
+        issues.push({
+          severity: "error",
+          message: `Falha ao ler o arquivo de sum\xE1rio (JSON corrompido): ${err.message}`,
+          fix: "Valide a integridade do JSON de summary.json."
+        });
+      }
+    }
+    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) {
+              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.`
+              });
+            }
+          }
         }
-        manifest.files[relPath] = generateHash(content);
       }
     }
+    const hasErrors = issues.some((issue) => issue.severity === "error");
+    return {
+      success: !hasErrors,
+      issues
+    };
   }
-  await processDirectory(path2.join(templatesDir, ".sauron"), path2.join(cwd, ".sauron"));
-  await processDirectory(path2.join(templatesDir, ".agents"), path2.join(cwd, ".agents"));
-  const agentsMdPath = path2.join(cwd, "AGENTS.md");
-  const agentsMdContent = `# Diretrizes Globais de Agentes (Sauron CLI)
-
-**Alvos:** ${aiTargets.join(", ")}
-**Severidade:** ${severity}
+};
 
-## Contexto do Projeto
-${projectContext}
+// src/features/doctor/doctor.command.ts
+async function runDoctorCommand(options) {
+  const cwd = process.cwd();
+  const session = new SessionContext({
+    json: !!options.json,
+    interactive: !options.json
+  });
+  const driver = PresentationRouter.createDriver(session);
+  if (!session.json) {
+    p3.intro(pc3.bgBlue(pc3.white(" Sauron Memory System - Diagn\xF3stico (Doctor) ")));
+  }
+  driver.startSpinner("Escaneando integridade do c\xE9rebro da IA...");
+  const doctorService = new DoctorService();
+  try {
+    const report = await doctorService.execute(cwd);
+    driver.stopSpinner("Auditoria conclu\xEDda.", report.success);
+    if (!session.json) {
+      if (report.issues.length === 0) {
+        driver.logSuccess("Nenhum problema encontrado. O Sauron est\xE1 \xEDntegro e em compliance!");
+      } else {
+        console.log("\nAnomalias Encontradas:");
+        for (const issue of report.issues) {
+          const badge = issue.severity === "error" ? pc3.red(pc3.bold(" ERROR ")) : pc3.yellow(pc3.bold(" WARNING "));
+          console.log(`
+[${badge}] ${issue.message}`);
+          if (issue.file) {
+            console.log(`  Arquivo: ${pc3.cyan(issue.file)}`);
+          }
+          if (issue.fix) {
+            console.log(`  Corre\xE7\xE3o recomendada: ${pc3.green(issue.fix)}`);
+          }
+        }
+        console.log("");
+      }
+    }
+    const message = report.success ? "Auditoria conclu\xEDda com sucesso. Zero erros graves detectados!" : `Auditoria conclu\xEDda com problemas. Foram encontrados ${report.issues.filter((i) => i.severity === "error").length} erros graves.`;
+    driver.finish({
+      success: report.success,
+      message,
+      payload: {
+        cwd,
+        success: report.success,
+        issues: report.issues
+      }
+    });
+  } catch (error) {
+    driver.stopSpinner("Erro na auditoria.", false);
+    driver.finish({
+      success: false,
+      message: `Falha cr\xEDtica durante a execu\xE7\xE3o do doctor: ${error.message}`
+    });
+  }
+}
 
-## Stack Tecnol\xF3gica
-${projectStack}
+// src/features/uninstall/uninstall.command.ts
+import pc4 from "picocolors";
+import * as p4 from "@clack/prompts";
 
-## Regra de Ouro (Write Obligation)
-Todos os agentes operando neste reposit\xF3rio est\xE3o estritamente obrigados a documentar qualquer altera\xE7\xE3o arquitetural, de regra de neg\xF3cio ou muta\xE7\xE3o de estado nas pastas \`.sauron\` e \`.agents\` correspondentes. A leitura passiva sem documenta\xE7\xE3o \xE9 considerada quebra de compliance.
+// src/features/uninstall/uninstall.service.ts
+import fs12 from "fs-extra";
+import path12 from "path";
+var UninstallService = class {
+  registryService = new RegistryService();
+  async execute(options) {
+    const { cwd, purge } = options;
+    const removedPaths = [];
+    await this.registryService.unregisterWorkspace(cwd);
+    removedPaths.push("~/.sauron/registry.json (descadastrado)");
+    const adapters = AdapterFactory.getAllAdapters();
+    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);
+      removedPaths.push("AGENTS.md");
+    }
+    const sauronDir = path12.join(cwd, ".sauron");
+    if (await fs12.pathExists(sauronDir)) {
+      if (purge) {
+        await fs12.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);
+          removedPaths.push(".sauron/.manifest.json");
+        }
+        removedPaths.push(".sauron/wiki/ (preservado como base est\xE1tica)");
+      }
+    }
+    return removedPaths;
+  }
+};
 
-*Gerado automaticamente pelo Sauron CLI.*
-`;
-  let shouldWriteAgents = true;
-  if (await fs2.pathExists(agentsMdPath)) {
-    const localAgents = await fs2.readFile(agentsMdPath, "utf8");
-    s.stop(`Conflito em AGENTS.md`);
-    const decision = await resolveConflict("AGENTS.md", localAgents, agentsMdContent, manifest.files["AGENTS.md"]);
-    s.start("Finalizando...");
-    if (decision === "ours") shouldWriteAgents = false;
-  }
-  if (shouldWriteAgents) {
-    await fs2.writeFile(agentsMdPath, agentsMdContent, "utf8");
-  }
-  manifest.files["AGENTS.md"] = generateHash(agentsMdContent);
-  await saveManifest(cwd, manifest);
-  s.stop("Inje\xE7\xE3o finalizada.");
-  p2.outro(
-    pc2.green(pc2.bold("Sauron Memory System instalado com sucesso!\n\n")) + pc2.white("O C\xE9rebro da IA foi injetado e protegido pelo motor de integridade.\n") + pc2.cyan("A\xE7\xF5es Recomendadas:\n") + pc2.dim("Copie o comando abaixo e envie para a sua IA testar a nova arquitetura:\n") + pc2.yellow('"Analise a estrutura .sauron/ e .agents/ rec\xE9m injetada e sugira quais regras cr\xEDticas eu devo documentar agora para nosso projeto."')
-  );
+// src/features/uninstall/uninstall.command.ts
+async function runUninstallCommand(options) {
+  const cwd = process.cwd();
+  const session = new SessionContext({
+    json: !!options.json,
+    interactive: !options.yes && !options.json
+  });
+  const driver = PresentationRouter.createDriver(session);
+  if (!session.json) {
+    p4.intro(pc4.bgRed(pc4.white(" Sauron Memory System - Desinstala\xE7\xE3o ")));
+  }
+  if (session.interactive) {
+    const confirm2 = await p4.confirm({
+      message: options.purge ? pc4.red("Tem certeza que deseja desinstalar o Sauron e PURGAR toda a wiki de documenta\xE7\xE3o f\xEDsica?") : "Tem certeza que deseja desinstalar o Sauron deste projeto (a wiki/ de documenta\xE7\xE3o ser\xE1 preservada)?"
+    });
+    if (p4.isCancel(confirm2) || !confirm2) {
+      p4.cancel("Desinstala\xE7\xE3o abortada.");
+      process.exit(0);
+    }
+  }
+  driver.startSpinner("Desinstalando Sauron e limpando vincula\xE7\xF5es de agentes...");
+  const uninstallService = new UninstallService();
+  try {
+    const removedPaths = await uninstallService.execute({
+      cwd,
+      purge: !!options.purge
+    });
+    driver.stopSpinner("Desinstala\xE7\xE3o conclu\xEDda.", true);
+    const message = options.purge ? "Sauron CLI desinstalado por completo e pasta wiki/ purgada com sucesso!" : "Sauron CLI desinstalado com sucesso! A base wiki/ foi preservada como hist\xF3rico de contexto.";
+    driver.finish({
+      success: true,
+      message,
+      payload: {
+        cwd,
+        purge: !!options.purge,
+        removedPaths
+      }
+    });
+  } catch (error) {
+    driver.stopSpinner("Erro ao desinstalar.", false);
+    driver.finish({
+      success: false,
+      message: `Falha cr\xEDtica durante a desinstala\xE7\xE3o: ${error.message}`
+    });
+  }
 }
 
 // src/index.ts
 var program = new Command();
-program.name("sauron").description("Sauron CLI - Framework para resolu\xE7\xE3o de Amn\xE9sia de Contexto em IAs").version("1.0.0");
-program.command("init").description("Inicializa o Sauron Memory System no projeto atual").option("-y, --yes", "Pula os prompts interativos e usa os valores padr\xE3o (N\xE3o-interativo)").action((options) => runInit(options));
+program.name("sauron").description("Sauron CLI - Framework para resolu\xE7\xE3o de Amn\xE9sia de Contexto em IAs").version("1.2.0");
+program.command("init").description("Inicializa o Sauron Memory System no projeto atual").option("-y, --yes", "Pula os prompts interativos e usa os valores padr\xE3o (N\xE3o-interativo)").option("--json", "Sa\xEDda do resultado em formato JSON estruturado").option("--conflict <resolution>", "Estrat\xE9gia de resolu\xE7\xE3o de conflitos autom\xE1tica (ours | theirs)").action((options) => runInitCommand(options));
+program.command("doctor").description("Executa uma auditoria de integridade e conformidade estrutural das regras e wiki").option("--json", "Sa\xEDda do relat\xF3rio em formato JSON estruturado").action((options) => runDoctorCommand(options));
+program.command("uninstall").description("Remove as vincula\xE7\xF5es do Sauron CLI e regras de assistentes locais").option("--purge", "Remove fisicamente a pasta .sauron/ incluindo a wiki de documenta\xE7\xE3o").option("-y, --yes", "Pula os prompts de confirma\xE7\xE3o de desinstala\xE7\xE3o").option("--json", "Sa\xEDda do resultado em formato JSON estruturado").action((options) => runUninstallCommand(options));
 program.parse();