ultracode 5.3.0 → 5.5.0

package/dist/chunks/autodoc-tool-handlers-EHTNCH6I.js

@@ -0,0 +1,1112 @@
+import './chunk-FTBE7VMY.js';
+import { AutoDocInitSchema, AutoDocSaveSchema, AutoDocGetSchema, AutoDocSearchSchema, AutoDocValidateSchema, AutoDocStatusSchema, AutoDocSyncSchema, AutoDocGenerateSchema, AutoDocChangelogSchema, AutoDocInstallHooksSchema, AutoDocDetectLanguageSchema } from './chunk-JP4AKI4T.js';
+import { BaseToolHandler } from './chunk-WLKASYMP.js';
+import './chunk-KMXE2SJJ.js';
+import './chunk-V2SCB5H5.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-L2X4HRXI.js';
+import './chunk-ZD54CMKT.js';
+import './chunk-HEMJHRHZ.js';
+import { writeDocumentToDisk } from './chunk-5RGY76OC.js';
+import { generateDocs } from './chunk-EOTZN6YO.js';
+import { toError } from './chunk-5WKPA33T.js';
+import './chunk-F7CKCMXI.js';
+import './chunk-BMHPPH2B.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-EZDL43GB.js';
+import './chunk-NAQKA54E.js';
+import path, { join } from 'path';
+import { execSync } from 'child_process';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+
+// src/autodoc/generator/generate-handler-utils.ts
+init_logging();
+var GENERAL_DOC_FILES = [
+  "architecture.md",
+  "dependencies.md",
+  "deployment.md",
+  "flow.md",
+  "glossary.md",
+  "processes.md"
+];
+var TEMPLATES = {
+  "architecture.md": `# Architecture
+
+## Overview
+
+*Describe the high-level architecture of your project here.*
+
+## Core Components
+
+| Component | Location | Description |
+|-----------|----------|-------------|
+| Example | [\`src/example.ts\`](../src/example.ts) | Description |
+
+## Data Flow
+
+\`\`\`
+[Request] \u2192 [Handler] \u2192 [Service] \u2192 [Storage]
+\`\`\`
+
+## Key Decisions
+
+| Decision | Rationale |
+|----------|-----------|
+| Example | Reason |
+
+## Related Documents
+
+- [\u2192 dependencies.md](./dependencies.md)
+- [\u2192 deployment.md](./deployment.md)
+- [\u2192 processes.md](./processes.md)
+`,
+  "dependencies.md": `# Dependencies
+
+## Runtime Dependencies
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| example | ^1.0.0 | Description |
+
+## Dev Dependencies
+
+| Package | Version | Purpose |
+|---------|---------|---------|
+| typescript | ^5.0.0 | Type checking |
+
+## System Requirements
+
+- Node.js 18+
+- *Add other requirements*
+
+## Optional Dependencies
+
+*List optional dependencies and when they are needed.*
+`,
+  "deployment.md": `# Deployment
+
+## Build
+
+\`\`\`bash
+npm run build
+\`\`\`
+
+## Configuration
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| NODE_ENV | development | Environment |
+
+## Installation
+
+\`\`\`bash
+npm install
+\`\`\`
+
+## Production Setup
+
+*Describe production deployment steps.*
+`,
+  "flow.md": `# Data Flow
+
+## Request Flow
+
+\`\`\`
+\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510     \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510     \u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510
+\u2502 Client  \u2502 \u2500\u2500\u25BA \u2502 Handler \u2502 \u2500\u2500\u25BA \u2502 Service \u2502
+\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518     \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518     \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518
+\`\`\`
+
+## Key Processes
+
+### Process 1
+
+1. Step one
+2. Step two
+3. Step three
+
+## State Management
+
+*Describe how state is managed.*
+`,
+  "glossary.md": `# Glossary
+
+## Terms
+
+| Term | Definition |
+|------|------------|
+| **Entity** | A code element (function, class, variable) tracked in the graph |
+| **Relationship** | A connection between entities (imports, calls, extends) |
+
+## Abbreviations
+
+| Abbr | Full Form |
+|------|-----------|
+| AST | Abstract Syntax Tree |
+| MCP | Model Context Protocol |
+`,
+  "processes.md": `# Processes
+
+## Development Workflow
+
+1. Create feature branch
+2. Implement changes
+3. Run tests
+4. Create PR
+
+## Testing
+
+\`\`\`bash
+npm test
+\`\`\`
+
+## Code Style
+
+*Describe code style guidelines.*
+
+## Release Process
+
+1. Update version
+2. Update changelog
+3. Create release tag
+`
+};
+function ensureGeneralDocs(autodocDir) {
+  if (!existsSync(autodocDir)) {
+    mkdirSync(autodocDir, { recursive: true });
+  }
+  for (const filename of GENERAL_DOC_FILES) {
+    const filePath = path.join(autodocDir, filename);
+    if (!existsSync(filePath)) {
+      writeFileSync(filePath, TEMPLATES[filename], "utf-8");
+    }
+  }
+}
+
+// src/autodoc/generator/generate-handler-utils.ts
+function findRepoRoot(targetDir) {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      cwd: targetDir,
+      encoding: "utf-8",
+      windowsHide: true,
+      stdio: ["pipe", "pipe", "pipe"]
+    }).trim();
+  } catch {
+    return targetDir;
+  }
+}
+async function detectDocLanguage(requestedLang, getAutoDocManager, autodocDir) {
+  if (requestedLang !== "auto") {
+    return requestedLang;
+  }
+  try {
+    const adm = await getAutoDocManager();
+    const configLang = adm?.getConfig()?.language;
+    if (configLang && configLang !== "auto" && configLang !== "en") {
+      return configLang;
+    }
+    const { readdir, readFile } = await import('fs/promises');
+    const { detectLanguageFromText, aggregateLanguageDetection } = await import('./language-detector-2YC3ZIGH.js');
+    const targetDir = autodocDir || join(process.cwd(), ".autodoc");
+    try {
+      const files = await readdir(targetDir);
+      const mdFiles = files.filter((f) => f.endsWith(".md")).slice(0, 5);
+      const results = [];
+      for (const file of mdFiles) {
+        try {
+          const content = await readFile(join(targetDir, file), "utf-8");
+          const result = detectLanguageFromText(content);
+          if (result.confidence > 0) {
+            results.push(result);
+          }
+        } catch {
+        }
+      }
+      if (results.length > 0) {
+        const aggregated = aggregateLanguageDetection(results);
+        if (aggregated.confidence > 0.3) {
+          log.d("AUTODOCGEN", "language_detected", { lang: aggregated.language, conf: aggregated.confidence });
+          return aggregated.language;
+        }
+      }
+    } catch {
+    }
+    return "en";
+  } catch {
+    return "en";
+  }
+}
+async function enhanceWithLLM(modules, files, docLanguage, _context) {
+  const { detectLLMProviders, batchGenerateDocs } = await import('./llm-YL3RLYED.js');
+  const { recommended } = await detectLLMProviders();
+  if (!recommended) {
+    log.w("AUTODOCGEN", "no_llm_provider", { hint: "Install Ollama or configure TGI/OpenAI" });
+    return { llmStatus: "no_provider_available" };
+  }
+  const modelName = recommended.selectedModel || recommended.name;
+  log.i("AUTODOCGEN", "using_llm", {
+    provider: recommended.name,
+    model: modelName,
+    modules: modules.length,
+    lang: docLanguage
+  });
+  try {
+    const enhancedDocs = await batchGenerateDocs(recommended, modules, {
+      concurrency: 1,
+      language: docLanguage,
+      onProgress: (completed, total) => {
+        log.d("AUTODOCGEN", "llm_progress", { completed, total });
+      }
+    });
+    for (const file of files) {
+      const enhanced = enhancedDocs.get(file.path.replace(/AUTODOC\.md$/, "").replace(/[\\/]$/, ""));
+      if (enhanced) {
+        file.content = enhanced;
+      }
+    }
+    return { llmStatus: `using_${recommended.name}:${modelName}` };
+  } catch (error) {
+    log.w("AUTODOCGEN", "llm_gen_failed", { error: error.message });
+    return { llmStatus: `error_${recommended.name}` };
+  }
+}
+async function writeFilesIncremental(files, adm, useLlm, _context) {
+  const { updateModuleDoc } = await import('./incremental-updater-KDIQGAUU.js');
+  let filesWritten = 0;
+  const incrementalChanges = [];
+  for (const file of files) {
+    try {
+      const modulePath = file.path.replace(/[\\/]AUTODOC\.md$/, "");
+      const updateResult = await updateModuleDoc(modulePath, file.path, file.content, { useLlm });
+      if (updateResult.updated && updateResult.newContent) {
+        if (adm) {
+          await adm.saveDocument(file.path, updateResult.newContent, { autoGenerated: true });
+        }
+        await writeDocumentToDisk(file.path, updateResult.newContent);
+        filesWritten++;
+        incrementalChanges.push({
+          path: file.path,
+          changes: updateResult.changes.map((c) => c.description)
+        });
+      }
+    } catch (error) {
+      log.w("AUTODOCGEN", "incr_update_failed", { path: file.path, error: error.message });
+      try {
+        if (adm) {
+          await adm.saveDocument(file.path, file.content, { autoGenerated: true });
+        }
+        await writeDocumentToDisk(file.path, file.content);
+        filesWritten++;
+      } catch (innerError) {
+        log.w("AUTODOCGEN", "write_failed", { path: file.path, error: innerError.message });
+      }
+    }
+  }
+  return { filesWritten, incrementalChanges };
+}
+async function writeFilesOverwrite(files, adm, _context) {
+  let filesWritten = 0;
+  for (const file of files) {
+    try {
+      if (adm) {
+        await adm.saveDocument(file.path, file.content, { autoGenerated: true });
+      }
+      await writeDocumentToDisk(file.path, file.content);
+      filesWritten++;
+    } catch (error) {
+      log.w("AUTODOCGEN", "write_failed", { path: file.path, error: error.message });
+    }
+  }
+  return filesWritten;
+}
+async function executeGenerateDocs(options, context) {
+  const targetDir = context.normalizeInputPath(options.rootDir || "") || process.cwd();
+  const repoRoot = findRepoRoot(targetDir);
+  const targetAutodocDir = options.autodocDir ? context.normalizeInputPath(options.autodocDir) || options.autodocDir : join(repoRoot, ".autodoc");
+  const docLanguage = await detectDocLanguage(options.language || "auto", context.getAutoDocManager, targetAutodocDir);
+  ensureGeneralDocs(targetAutodocDir);
+  const result = await generateDocs({
+    rootDir: targetDir,
+    exclude: options.exclude,
+    maxDepth: options.maxDepth
+  });
+  if (options.module) {
+    const filterLower = options.module.toLowerCase();
+    result.modules = result.modules.filter(
+      (m) => m.name.toLowerCase() === filterLower || m.name.toLowerCase().includes(filterLower)
+    );
+    result.files = result.files.filter((f) => result.modules.some((m) => f.path.includes(m.path)));
+  }
+  let llmStatus = "not_requested";
+  if (options.useLlm && result.modules.length > 0) {
+    const llmResult = await enhanceWithLLM(result.modules, result.files, docLanguage);
+    llmStatus = llmResult.llmStatus;
+  }
+  let filesWritten = 0;
+  let incrementalChanges = [];
+  if (!options.preview) {
+    const adm = await context.getAutoDocManager();
+    if (options.incremental) {
+      const writeResult = await writeFilesIncremental(result.files, adm, options.useLlm || false);
+      filesWritten = writeResult.filesWritten;
+      incrementalChanges = writeResult.incrementalChanges;
+    } else {
+      filesWritten = await writeFilesOverwrite(result.files, adm);
+    }
+  }
+  return {
+    success: true,
+    preview: options.preview || false,
+    useLlm: options.useLlm || false,
+    llmStatus,
+    incremental: options.incremental || false,
+    language: docLanguage,
+    modulesFound: result.modules.length,
+    filesToGenerate: result.files.length,
+    filesWritten,
+    incrementalChanges: options.incremental ? incrementalChanges : void 0,
+    modules: result.modules.map((m) => ({
+      name: m.name,
+      path: m.path,
+      files: m.files.length,
+      exports: m.exports.slice(0, 5)
+    })),
+    files: result.files.map((f) => ({
+      path: f.path,
+      type: f.type,
+      preview: options.preview ? f.content.slice(0, 200) + "..." : void 0
+    }))
+  };
+}
+
+// src/tools/handlers/autodoc-tool-handlers.ts
+init_logging();
+async function getAutoDocManagerFromContext(context) {
+  const container = context.getServiceContainer?.();
+  if (!container) {
+    return null;
+  }
+  const adm = await container.getAutoDocManager();
+  if (adm && !adm.isInitialized()) {
+    const graphStorage = await container.getGraphStorage?.();
+    await adm.initialize(graphStorage);
+  }
+  return adm;
+}
+function autodocNotEnabledResult() {
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify({
+          success: false,
+          error: "AutoDoc not enabled. Create .autodoc folder in project root to enable."
+        })
+      }
+    ]
+  };
+}
+var AutoDocInitToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocInitSchema.parse(args);
+  }
+  async execute(args) {
+    const container = this.context.getServiceContainer?.();
+    if (!container) {
+      return autodocNotEnabledResult();
+    }
+    const adm = await container.getAutoDocManager();
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    adm.setConfig({
+      enabled: args.enabled,
+      language: args.language,
+      docsDir: args.docsDir || join(container.directory, ".memory_bank")
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              message: "AutoDoc initialized",
+              config: adm.getConfig()
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocSaveToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocSaveSchema.parse(args);
+  }
+  async execute(args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    const normalizedPath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+    const saveOptions = {
+      type: args.type,
+      autoGenerated: args.autoGenerated
+    };
+    const savedDocs = await adm.saveDocument(normalizedPath, args.content, saveOptions);
+    let fileWritten = false;
+    try {
+      const { writeDocumentToDisk: writeDocumentToDisk2 } = await import('./file-sync-F6G6OINI.js');
+      await writeDocumentToDisk2(normalizedPath, args.content);
+      fileWritten = true;
+    } catch (error) {
+      const err = toError(error);
+      log.w("AUTODOCTOOL", "file_write_failed", { error: err.message, path: normalizedPath, stack: err.stack });
+    }
+    let embeddingsGenerated = 0;
+    const debugInfo = { savedDocsCount: savedDocs.length };
+    if (savedDocs.length > 0) {
+      try {
+        log.i("AUTODOCTOOL", "embeddings_start", { docsCount: savedDocs.length });
+        debugInfo.step = "getSemanticAgent";
+        const semanticAgent = await this.context.getSemanticAgent();
+        debugInfo.hasAgent = !!semanticAgent;
+        debugInfo.agentType = typeof semanticAgent;
+        log.i("AUTODOCTOOL", "embeddings_agent", { hasAgent: !!semanticAgent, agentType: typeof semanticAgent });
+        debugInfo.step = "getVectorStore";
+        const vectorStore = semanticAgent?.getVectorStore?.();
+        debugInfo.hasStore = !!vectorStore;
+        debugInfo.hasGetVectorStoreFn = typeof semanticAgent?.getVectorStore;
+        log.i("AUTODOCTOOL", "embeddings_store", {
+          hasStore: !!vectorStore,
+          storeType: typeof vectorStore,
+          hasGetVectorStore: typeof semanticAgent?.getVectorStore
+        });
+        if (semanticAgent && vectorStore) {
+          debugInfo.step = "processing";
+          debugInfo.agentAndStoreOk = true;
+          log.i("AUTODOCTOOL", "embeddings_processing", { count: savedDocs.length });
+          const docIds = savedDocs.map((d) => d.id);
+          const existingIds = await vectorStore.getExistingIds(docIds);
+          log.i("AUTODOCTOOL", "embeddings_existing_check", { total: docIds.length, existing: existingIds.size });
+          for (const doc of savedDocs) {
+            const textToEmbed = `${doc.title}
+
+${doc.content}`;
+            const embedding = await semanticAgent.generateEmbedding(textToEmbed);
+            if (embedding) {
+              const exists = existingIds.has(doc.id);
+              log.i("AUTODOCTOOL", exists ? "updating_embedding" : "inserting_embedding", {
+                id: doc.id,
+                vectorDim: embedding.length,
+                contentLen: textToEmbed.length
+              });
+              const metadata = {
+                type: "autodoc",
+                docType: doc.type,
+                filePath: doc.filePath,
+                section: doc.section,
+                title: doc.title
+              };
+              if (exists) {
+                await vectorStore.update(doc.id, embedding, metadata);
+              } else {
+                await vectorStore.insert({
+                  id: doc.id,
+                  content: textToEmbed.slice(0, 1e3),
+                  vector: embedding,
+                  metadata,
+                  createdAt: Date.now()
+                });
+              }
+              embeddingsGenerated++;
+              log.d("AUTODOCTOOL", "embedding_saved", { id: doc.id, operation: exists ? "update" : "insert" });
+            }
+          }
+          log.i("AUTODOCTOOL", "embeddings_done", { generated: embeddingsGenerated });
+          if (embeddingsGenerated > 0) {
+            log.i("AUTODOCTOOL", "flushing_embeddings");
+            await vectorStore.flushAndSave();
+            log.i("AUTODOCTOOL", "embeddings_flushed");
+          }
+        } else {
+          debugInfo.skipped = true;
+          debugInfo.reason = `agent=${!!semanticAgent}, store=${!!vectorStore}`;
+          log.w("AUTODOCTOOL", "embeddings_skipped", { hasAgent: !!semanticAgent, hasStore: !!vectorStore });
+        }
+      } catch (error) {
+        const err = toError(error);
+        debugInfo.error = err.message;
+        debugInfo.stack = err.stack;
+        log.e("AUTODOCTOOL", "embedding_failed", { error: err.message, stack: err.stack });
+      }
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              message: `Saved ${savedDocs.length} sections`,
+              fileWritten,
+              embeddingsGenerated,
+              debug: debugInfo,
+              docs: savedDocs.map((d) => ({
+                id: d.id,
+                title: d.title,
+                section: d.section
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocGetToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocGetSchema.parse(args);
+  }
+  async execute(args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    if (args.docId) {
+      const doc = await adm.getDocument(args.docId);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: !!doc,
+                doc: doc || null
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    if (args.filePath) {
+      const normalizedPath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+      const docs = await adm.getDocumentsByFile(normalizedPath);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                count: docs.length,
+                docs
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ success: false, error: "Provide docId or filePath" }, null, 2)
+        }
+      ]
+    };
+  }
+};
+var AutoDocSearchToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocSearchSchema.parse(args);
+  }
+  async execute(args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    const searchResults = [];
+    if (args.mode === "text" || args.mode === "hybrid") {
+      const textResults = await adm.searchDocsByText(args.query, args.limit);
+      for (const d of textResults) {
+        searchResults.push({
+          id: d.id,
+          title: d.title,
+          filePath: d.filePath,
+          section: d.section,
+          snippet: d.content.slice(0, 200),
+          source: "text"
+        });
+      }
+    }
+    if (args.mode === "semantic" || args.mode === "hybrid") {
+      try {
+        const semanticAgent = await this.context.getSemanticAgent();
+        const vectorStore = semanticAgent?.getVectorStore?.();
+        if (semanticAgent && vectorStore) {
+          const queryEmbedding = await semanticAgent.generateEmbedding(args.query);
+          log.i("AUTODOCTOOL", "search_embedding_generated", {
+            hasEmbedding: !!queryEmbedding,
+            dim: queryEmbedding?.length
+          });
+          if (queryEmbedding) {
+            const semanticResults = await vectorStore.searchWithFilters(queryEmbedding, {
+              limit: args.limit,
+              metadataFilter: { type: "autodoc" }
+            });
+            log.i("AUTODOCTOOL", "search_results", {
+              count: semanticResults.length,
+              ids: semanticResults.map((r) => r.id).slice(0, 5)
+            });
+            for (const result of semanticResults) {
+              log.d("AUTODOCTOOL", "search_result_check", {
+                id: result.id,
+                startsWithDoc: result.id.startsWith("doc::")
+              });
+              if (result.id.startsWith("doc::")) {
+                const doc = await adm.getDocument(result.id);
+                if (doc && !searchResults.some((r) => r.id === doc.id)) {
+                  searchResults.push({
+                    id: doc.id,
+                    title: doc.title,
+                    filePath: doc.filePath,
+                    section: doc.section,
+                    snippet: doc.content.slice(0, 200),
+                    score: result.similarity,
+                    source: "semantic"
+                  });
+                }
+              }
+            }
+          }
+        }
+      } catch (error) {
+        const err = toError(error);
+        log.w("AUTODOCTOOL", "semantic_search_err", { error: err.message, stack: err.stack });
+      }
+    }
+    searchResults.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              query: args.query,
+              mode: args.mode || "text",
+              resultsCount: searchResults.length,
+              results: searchResults.slice(0, args.limit)
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocValidateToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocValidateSchema.parse(args);
+  }
+  async execute(args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    const validation = await adm.validateReferences();
+    const result = {
+      success: true,
+      total: validation.total,
+      valid: validation.valid,
+      broken: validation.broken.length
+    };
+    if (args.filePath) {
+      const normalizedPath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+      result.brokenInFile = validation.broken.filter(
+        (b) => b.ref.sourceLocation.filePath === normalizedPath
+      );
+    } else {
+      result.brokenRefs = validation.broken.slice(0, 20);
+    }
+    return {
+      content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
+    };
+  }
+};
+var AutoDocStatusToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocStatusSchema.parse(args);
+  }
+  async execute(_args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    const status = await adm.getStatus();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              status
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocSyncToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocSyncSchema.parse(args);
+  }
+  async execute(args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    const { syncBidirectional, syncDbToDisk, syncDiskToDb } = await import('./file-sync-F6G6OINI.js');
+    const syncResult = {
+      validated: 0,
+      brokenRefs: 0,
+      outdatedDocs: 0,
+      markedOutdated: []
+    };
+    if (args.docsDir) {
+      const normalizedDocsDir = this.context.normalizeInputPath(args.docsDir) || args.docsDir;
+      const getDocsAsEntities = async (fp) => {
+        return adm.getDocumentsByFile(fp);
+      };
+      const getAllDocsAsEntities = async () => {
+        return adm.getAllDocuments();
+      };
+      if (args.direction === "disk-to-db") {
+        const diskToDb = await syncDiskToDb(
+          normalizedDocsDir,
+          getDocsAsEntities,
+          async (fp, content) => {
+            await adm.saveDocument(fp, content);
+            return [];
+          },
+          8
+        );
+        syncResult.fileSync = {
+          diskToDb: {
+            added: diskToDb.added,
+            updated: diskToDb.updated,
+            errors: diskToDb.errors.map((e) => ({ path: e.file, error: e.error }))
+          },
+          dbToDisk: { written: [], errors: [] }
+        };
+      } else if (args.direction === "db-to-disk") {
+        const dbToDisk = await syncDbToDisk(getAllDocsAsEntities, 8);
+        syncResult.fileSync = {
+          diskToDb: { added: [], updated: [], errors: [] },
+          dbToDisk: {
+            written: dbToDisk.written,
+            errors: dbToDisk.errors.map((e) => ({ path: e.file, error: e.error }))
+          }
+        };
+      } else {
+        const bidirectional = await syncBidirectional(
+          normalizedDocsDir,
+          getDocsAsEntities,
+          getAllDocsAsEntities,
+          async (fp, content) => {
+            await adm.saveDocument(fp, content);
+            return [];
+          },
+          8
+        );
+        syncResult.fileSync = {
+          diskToDb: {
+            added: bidirectional.diskToDb.added,
+            updated: bidirectional.diskToDb.updated,
+            errors: bidirectional.diskToDb.errors.map((e) => ({ path: e.file, error: e.error }))
+          },
+          dbToDisk: {
+            written: bidirectional.dbToDisk.written,
+            errors: bidirectional.dbToDisk.errors.map((e) => ({ path: e.file, error: e.error }))
+          }
+        };
+      }
+    }
+    const validation = await adm.validateReferences();
+    syncResult.validated = validation.total;
+    syncResult.brokenRefs = validation.broken.length;
+    const outdated = await adm.getOutdatedDocs();
+    syncResult.outdatedDocs = outdated.length;
+    if (args.scope === "file" && args.filePath) {
+      const normalizedPath = this.context.normalizeInputPath(args.filePath) || args.filePath;
+      const fileDocs = await adm.getDocumentsByFile(normalizedPath);
+      for (const doc of fileDocs) {
+        if (doc.confidence && doc.confidence < 0.7) {
+          syncResult.markedOutdated.push(doc.id);
+        }
+      }
+    } else {
+      syncResult.markedOutdated = outdated.map((o) => o.docId);
+    }
+    const fileSyncMsg = syncResult.fileSync ? ` Files: ${syncResult.fileSync.diskToDb.added.length} added, ${syncResult.fileSync.diskToDb.updated.length} updated, ${syncResult.fileSync.dbToDisk.written.length} written.` : "";
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              message: `Sync completed. ${syncResult.brokenRefs} broken refs, ${syncResult.outdatedDocs} outdated docs.${fileSyncMsg}`,
+              ...syncResult
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocGenerateToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocGenerateSchema.parse(args);
+  }
+  async execute(args) {
+    const container = this.context.getServiceContainer?.();
+    if (!container) {
+      return autodocNotEnabledResult();
+    }
+    let useLlm = args.useLlm;
+    if (useLlm === void 0) {
+      try {
+        const { detectLLMProviders } = await import('./llm-provider-J6V62H56.js');
+        const { recommended } = await detectLLMProviders();
+        useLlm = !!recommended;
+      } catch {
+        useLlm = false;
+      }
+    }
+    const result = await executeGenerateDocs(
+      {
+        rootDir: args.rootDir,
+        autodocDir: args.autodocDir,
+        exclude: args.exclude,
+        maxDepth: args.maxDepth,
+        module: args.module,
+        useLlm,
+        preview: args.preview,
+        incremental: args.incremental,
+        language: args.language
+      },
+      {
+        normalizeInputPath: this.context.normalizeInputPath,
+        requestId: this.context.requestId,
+        getAutoDocManager: container.getAutoDocManager.bind(container)
+      }
+    );
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(result, null, 2)
+        }
+      ]
+    };
+  }
+};
+var AutoDocChangelogToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocChangelogSchema.parse(args);
+  }
+  async execute(args) {
+    const adm = await getAutoDocManagerFromContext(this.context);
+    if (!adm) {
+      return autodocNotEnabledResult();
+    }
+    const changelog = await adm.getChangelog({
+      since: args.since,
+      limit: args.limit,
+      branch: args.branch
+    });
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              entriesCount: changelog.length,
+              entries: changelog.map((entry) => ({
+                id: entry.id,
+                timestamp: entry.timestamp,
+                date: new Date(entry.timestamp).toISOString(),
+                branch: entry.branch,
+                summary: entry.summary,
+                changesCount: entry.changes?.length || 0,
+                impactedDocsCount: entry.impactedDocs?.length || 0
+              }))
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocInstallHooksToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocInstallHooksSchema.parse(args);
+  }
+  async execute(args) {
+    const container = this.context.getServiceContainer?.();
+    if (!container) {
+      return {
+        content: [{ type: "text", text: JSON.stringify({ error: "ServiceContainer not available" }) }]
+      };
+    }
+    const { installPreCommitHook, uninstallHooks, getHookStatus } = await import('./hook-installer-UDHK3ZRM.js');
+    const projectPath = container.directory;
+    if (args.action === "status") {
+      const status = await getHookStatus(projectPath);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: true,
+                gitRepo: status.gitRepo,
+                hooksDir: status.hooksDir,
+                preCommitInstalled: status.preCommit
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    if (args.action === "uninstall") {
+      const result2 = await uninstallHooks(projectPath);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(
+              {
+                success: result2.success,
+                removed: result2.installed,
+                skipped: result2.skipped,
+                errors: result2.errors
+              },
+              null,
+              2
+            )
+          }
+        ]
+      };
+    }
+    const result = await installPreCommitHook(projectPath);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: result.success,
+              installed: result.installed,
+              skipped: result.skipped,
+              errors: result.errors
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+var AutoDocDetectLanguageToolHandler = class extends BaseToolHandler {
+  parseArgs(args) {
+    return AutoDocDetectLanguageSchema.parse(args);
+  }
+  async execute(args) {
+    const { detectLanguageFromText, aggregateLanguageDetection } = await import('./language-detector-2YC3ZIGH.js');
+    const results = [];
+    if (args.scope === "comments" || args.scope === "all") {
+      const graphStorage = await this.context.getGraphStorage();
+      const allEntities = await graphStorage.getAllEntities();
+      const entities = allEntities.slice(0, args.sampleSize * 2);
+      let analyzed = 0;
+      for (const entity of entities) {
+        if (analyzed >= args.sampleSize) break;
+        const commentsSource = entity.metadata?.["comments"] || entity.documentation;
+        if (commentsSource) {
+          const commentsText = Array.isArray(commentsSource) ? commentsSource.join("\n") : String(commentsSource);
+          const result = detectLanguageFromText(commentsText);
+          if (result.confidence > 0) {
+            results.push(result);
+            analyzed++;
+          }
+        }
+      }
+    }
+    if (args.scope === "docs" || args.scope === "all") {
+      const adm = await getAutoDocManagerFromContext(this.context);
+      if (adm) {
+        const allDocs = await adm.searchDocsByText("", args.sampleSize);
+        for (const doc of allDocs) {
+          const result = detectLanguageFromText(doc.content);
+          if (result.confidence > 0) {
+            results.push(result);
+          }
+        }
+      }
+    }
+    const aggregated = aggregateLanguageDetection(results);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify(
+            {
+              success: true,
+              detectedLanguage: aggregated.language,
+              confidence: Math.round(aggregated.confidence * 100) / 100,
+              samplesAnalyzed: results.length,
+              charCounts: aggregated.charCounts,
+              recommendation: aggregated.confidence > 0.5 ? `Use language: ${aggregated.language}` : "Low confidence - defaulting to 'en'"
+            },
+            null,
+            2
+          )
+        }
+      ]
+    };
+  }
+};
+
+export { AutoDocChangelogToolHandler, AutoDocDetectLanguageToolHandler, AutoDocGenerateToolHandler, AutoDocGetToolHandler, AutoDocInitToolHandler, AutoDocInstallHooksToolHandler, AutoDocSaveToolHandler, AutoDocSearchToolHandler, AutoDocStatusToolHandler, AutoDocSyncToolHandler, AutoDocValidateToolHandler };
+//# sourceMappingURL=autodoc-tool-handlers-EHTNCH6I.js.map
+//# sourceMappingURL=autodoc-tool-handlers-EHTNCH6I.js.map