agentic-qe 3.8.7 → 3.8.9

package/dist/cli/commands/init.js

@@ -41,6 +41,7 @@ export function createInitCommand() {
         .option('--with-codex', 'Include OpenAI Codex CLI MCP config and AGENTS.md')
         .option('--with-windsurf', 'Include Windsurf MCP config and rules')
         .option('--with-continuedev', 'Include Continue.dev MCP config and rules')
+        .option('--with-mcp', 'Include MCP server config in .mcp.json (opt-in — CLI works without MCP)')
         .option('--with-all-platforms', 'Include all coding agent platform configurations')
         .option('--with-claude-flow', 'Force Claude Flow integration setup')
         .option('--skip-claude-flow', 'Skip Claude Flow integration')
@@ -113,6 +114,7 @@ async function runInit(options) {
         withCodex: options.withCodex,
         withWindsurf: options.withWindsurf,
         withContinueDev: options.withContinuedev,
+        withMcp: options.withMcp,
         noGovernance: options.noGovernance,
     });
     // Run initialization

package/dist/cli/commands/memory.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Agentic QE v3 - Memory CLI Commands
+ *
+ * CLI interface for memory store/get/search/delete/share operations.
+ * Provides CLI parity with MCP memory_store, memory_retrieve, memory_query,
+ * memory_delete, and memory_share tools to reduce MCP dependency in agents/skills.
+ */
+import { Command } from 'commander';
+import type { CLIContext } from '../handlers/interfaces.js';
+export declare function createMemoryCommand(context: CLIContext, cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): Command;
+//# sourceMappingURL=memory.d.ts.map

package/dist/cli/commands/memory.js

@@ -0,0 +1,333 @@
+/**
+ * Agentic QE v3 - Memory CLI Commands
+ *
+ * CLI interface for memory store/get/search/delete/share operations.
+ * Provides CLI parity with MCP memory_store, memory_retrieve, memory_query,
+ * memory_delete, and memory_share tools to reduce MCP dependency in agents/skills.
+ */
+import { Command } from 'commander';
+import chalk from 'chalk';
+import { toErrorMessage } from '../../shared/error-utils.js';
+export function createMemoryCommand(context, cleanupAndExit, ensureInitialized) {
+    const memory = new Command('memory')
+        .description('Memory store, retrieve, search, and delete operations')
+        .addHelpText('after', `
+Examples:
+  # Store a value
+  aqe memory store --key "auth-pattern" --value "JWT with refresh tokens" --namespace patterns
+
+  # Retrieve a value
+  aqe memory get --key "auth-pattern" --namespace patterns
+
+  # Search by pattern (glob)
+  aqe memory search --pattern "auth*" --namespace patterns
+
+  # Search semantically (natural language)
+  aqe memory search --query "authentication patterns" --semantic
+
+  # List all entries in a namespace
+  aqe memory list --namespace patterns --limit 20
+
+  # Delete a key
+  aqe memory delete --key "auth-pattern" --namespace patterns
+
+  # Share knowledge between agents
+  aqe memory share --from agent-1 --to agent-2,agent-3 --domain testing --content '{"finding": "flaky"}'
+
+  # Show usage stats
+  aqe memory usage
+`);
+    // ── store ──────────────────────────────────────────────────────────────
+    memory
+        .command('store')
+        .description('Store a key-value pair in memory')
+        .requiredOption('--key <key>', 'Memory key')
+        .requiredOption('--value <value>', 'Value to store (string or JSON)')
+        .option('--namespace <ns>', 'Namespace for grouping', 'default')
+        .option('--ttl <seconds>', 'Time-to-live in seconds')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryStore } = await import('../../mcp/handlers/memory-handlers.js');
+            // Try to parse value as JSON, otherwise store as string
+            let value = options.value;
+            try {
+                value = JSON.parse(options.value);
+            }
+            catch { /* keep as string */ }
+            const result = await handleMemoryStore({
+                key: options.key,
+                value,
+                namespace: options.namespace,
+                ttl: options.ttl ? parseInt(options.ttl, 10) : undefined,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success) {
+                console.log(chalk.green(`  ✓ Stored "${options.key}" in namespace "${options.namespace}"`));
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    // ── get ─────────────────────────────────────────────────────────────────
+    memory
+        .command('get')
+        .description('Retrieve a value by key')
+        .requiredOption('--key <key>', 'Memory key to retrieve')
+        .option('--namespace <ns>', 'Namespace', 'default')
+        .option('--include-metadata', 'Include metadata in response')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryRetrieve } = await import('../../mcp/handlers/memory-handlers.js');
+            const result = await handleMemoryRetrieve({
+                key: options.key,
+                namespace: options.namespace,
+                includeMetadata: options.includeMetadata,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success && result.data) {
+                if (result.data.found) {
+                    const val = typeof result.data.value === 'string'
+                        ? result.data.value
+                        : JSON.stringify(result.data.value, null, 2);
+                    console.log(chalk.green(`  ${options.key}`) + chalk.gray(` [${options.namespace}]`));
+                    console.log(`  ${val}`);
+                }
+                else {
+                    console.log(chalk.yellow(`  Key "${options.key}" not found in namespace "${options.namespace}"`));
+                }
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    // ── search ──────────────────────────────────────────────────────────────
+    memory
+        .command('search')
+        .description('Search memory by pattern (glob) or semantic query')
+        .option('--pattern <glob>', 'Glob pattern to match keys (e.g., "auth*")')
+        .option('--query <text>', 'Natural language query (implies --semantic)')
+        .option('--semantic', 'Use HNSW vector search for semantic matching')
+        .option('--namespace <ns>', 'Namespace to search in', 'default')
+        .option('--limit <n>', 'Maximum results', '20')
+        .option('--offset <n>', 'Skip first N results', '0')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!options.pattern && !options.query) {
+            console.error(chalk.red('  Either --pattern or --query is required'));
+            await cleanupAndExit(1);
+        }
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryQuery } = await import('../../mcp/handlers/memory-handlers.js');
+            const searchPattern = options.query || options.pattern;
+            const useSemantic = options.semantic || !!options.query;
+            const result = await handleMemoryQuery({
+                pattern: searchPattern,
+                namespace: options.namespace,
+                limit: parseInt(options.limit, 10),
+                offset: parseInt(options.offset, 10),
+                semantic: useSemantic,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success && result.data) {
+                const { entries, total, searchType } = result.data;
+                console.log(chalk.blue(`  ${total} result(s) via ${searchType} search\n`));
+                for (const entry of entries) {
+                    const score = entry.score !== undefined ? chalk.gray(` (score: ${entry.score.toFixed(3)})`) : '';
+                    console.log(`  ${chalk.green(entry.key)} ${chalk.gray(`[${entry.namespace}]`)}${score}`);
+                }
+                if (result.data.hasMore) {
+                    console.log(chalk.gray(`\n  ... and more. Use --offset ${parseInt(options.offset, 10) + parseInt(options.limit, 10)} to see next page`));
+                }
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    // ── list ────────────────────────────────────────────────────────────────
+    memory
+        .command('list')
+        .description('List all memory entries in a namespace')
+        .option('--namespace <ns>', 'Namespace to list', 'default')
+        .option('--limit <n>', 'Maximum results', '50')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryQuery } = await import('../../mcp/handlers/memory-handlers.js');
+            const result = await handleMemoryQuery({
+                pattern: '*',
+                namespace: options.namespace,
+                limit: parseInt(options.limit, 10),
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success && result.data) {
+                console.log(chalk.blue(`  ${result.data.total} entries in namespace "${options.namespace}"\n`));
+                for (const entry of result.data.entries) {
+                    console.log(`  ${chalk.green(entry.key)}`);
+                }
+                if (result.data.hasMore) {
+                    console.log(chalk.gray(`\n  ... more entries exist. Use --limit to see more.`));
+                }
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    // ── delete ──────────────────────────────────────────────────────────────
+    memory
+        .command('delete')
+        .description('Delete a memory entry by key')
+        .requiredOption('--key <key>', 'Memory key to delete')
+        .option('--namespace <ns>', 'Namespace', 'default')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryDelete } = await import('../../mcp/handlers/memory-handlers.js');
+            const result = await handleMemoryDelete({
+                key: options.key,
+                namespace: options.namespace,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success && result.data) {
+                if (result.data.deleted) {
+                    console.log(chalk.green(`  ✓ Deleted "${options.key}" from namespace "${options.namespace}"`));
+                }
+                else {
+                    console.log(chalk.yellow(`  Key "${options.key}" not found in namespace "${options.namespace}"`));
+                }
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    // ── share ───────────────────────────────────────────────────────────────
+    memory
+        .command('share')
+        .description('Share knowledge between agents')
+        .requiredOption('--from <agentId>', 'Source agent ID')
+        .requiredOption('--to <agentIds>', 'Comma-separated target agent IDs')
+        .requiredOption('--domain <domain>', 'Knowledge domain')
+        .requiredOption('--content <json>', 'JSON content to share')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryShare } = await import('../../mcp/handlers/memory-handlers.js');
+            let content;
+            try {
+                content = JSON.parse(options.content);
+            }
+            catch {
+                console.error(chalk.red('  --content must be valid JSON'));
+                await cleanupAndExit(1);
+                return; // unreachable but satisfies TS
+            }
+            const targetIds = options.to.split(',').map((s) => s.trim());
+            const result = await handleMemoryShare({
+                sourceAgentId: options.from,
+                targetAgentIds: targetIds,
+                knowledgeDomain: options.domain,
+                knowledgeContent: content,
+            });
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success && result.data) {
+                console.log(chalk.green(`  ✓ Shared knowledge from ${result.data.sourceAgent} to ${result.data.targetAgents.join(', ')}`));
+                console.log(chalk.gray(`    Domain: ${result.data.domain}`));
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    // ── usage ───────────────────────────────────────────────────────────────
+    memory
+        .command('usage')
+        .description('Show memory usage statistics')
+        .option('--json', 'Output as JSON')
+        .action(async (options) => {
+        if (!await ensureInitialized())
+            return;
+        try {
+            const { handleMemoryUsage } = await import('../../mcp/handlers/memory-handlers.js');
+            const result = await handleMemoryUsage();
+            if (options.json) {
+                console.log(JSON.stringify(result, null, 2));
+            }
+            else if (result.success && result.data) {
+                console.log(chalk.blue('  Memory Usage\n'));
+                console.log(`  Entries:    ${chalk.green(String(result.data.entries))}`);
+                console.log(`  Vectors:    ${chalk.green(String(result.data.vectors))}`);
+                console.log(`  Namespaces: ${chalk.green(String(result.data.namespaces))}`);
+            }
+            else {
+                console.error(chalk.red(`  ✗ ${result.error}`));
+                await cleanupAndExit(1);
+            }
+        }
+        catch (error) {
+            console.error(chalk.red(`  Error: ${toErrorMessage(error)}`));
+            await cleanupAndExit(1);
+        }
+    });
+    return memory;
+}
+//# sourceMappingURL=memory.js.map

package/dist/cli/commands/ruvector-commands.js

@@ -9,6 +9,7 @@
 import { Command } from 'commander';
 import chalk from 'chalk';
 import { getRuVectorFeatureFlags, setRuVectorFeatureFlags, DEFAULT_FEATURE_FLAGS, } from '../../integrations/ruvector/feature-flags.js';
+import { HnswAdapter } from '../../kernel/hnsw-adapter.js';
 // ============================================================================
 // Constants
 // ============================================================================
@@ -44,7 +45,7 @@ const FLAG_DESCRIPTIONS = {
     useHnswHealthMonitor: 'HNSW health monitor (Task 3.4)',
     useRegretTracking: 'Regret tracking & learning health (Task 2.4)',
     useCoherenceGate: 'Sheaf-gated coherence validation (ADR-083, Task 3.1)',
-    useWitnessChain: 'Blake3 hash-chained witness records (Task 3.1)',
+    useWitnessChain: 'SHA-256 hash-chained witness records (Task 3.1)',
     useCNNVisualRegression: 'CNN visual regression testing (Task 4.3)',
     useDAGAttention: 'DAG attention for test scheduling (Task 4.2)',
     useCoherenceActionGate: 'Coherence-gated agent actions (ADR-083, Task 3.2)',
@@ -102,6 +103,15 @@ function isDefaultValue(flag, value) {
 function padRight(str, length) {
     return str.padEnd(length);
 }
+function formatBytes(bytes) {
+    if (bytes < 1024)
+        return `${bytes}B`;
+    if (bytes < 1024 * 1024)
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    if (bytes < 1024 * 1024 * 1024)
+        return `${(bytes / (1024 * 1024)).toFixed(1)}MB`;
+    return `${(bytes / (1024 * 1024 * 1024)).toFixed(2)}GB`;
+}
 function isValidFlagName(name) {
     return VALID_FLAG_NAMES.includes(name);
 }
@@ -134,6 +144,36 @@ function executeStatus() {
         const suffix = isDefault ? chalk.gray(' (default)') : chalk.yellow(' (modified)');
         console.log(`    ${padRight(flagName + ':', 30)} ${valueText}${suffix}`);
     }
+    // HNSW Memory Usage
+    const indexNames = HnswAdapter.listIndexes();
+    if (indexNames.length > 0) {
+        console.log('');
+        console.log(chalk.cyan('  HNSW Memory Usage:'));
+        let totalVectors = 0;
+        let totalEstimatedBytes = 0;
+        for (const name of indexNames) {
+            const adapter = HnswAdapter.get(name);
+            if (adapter) {
+                const count = adapter.size();
+                const dims = adapter.dimensions();
+                // Raw vectors + HNSW graph overhead (~2x)
+                const rawBytes = count * dims * 4;
+                const estimatedBytes = rawBytes * 3;
+                totalVectors += count;
+                totalEstimatedBytes += estimatedBytes;
+                console.log(`    ${padRight(name + ':', 20)} ${chalk.white(String(count))} vectors, ` +
+                    `${chalk.white(dims)}d, ~${chalk.white(formatBytes(estimatedBytes))}`);
+            }
+        }
+        console.log(chalk.gray(`    ${'─'.repeat(50)}`));
+        console.log(`    ${padRight('Total:', 20)} ${chalk.bold.white(String(totalVectors))} vectors, ` +
+            `~${chalk.bold.white(formatBytes(totalEstimatedBytes))}`);
+    }
+    else {
+        console.log('');
+        console.log(chalk.cyan('  HNSW Memory Usage:'));
+        console.log(chalk.gray('    No active indexes (indexes are created on first use)'));
+    }
     // Memory info when compression is enabled
     if (flags.useTemporalCompression) {
         console.log('');

package/dist/cli/handlers/init-handler.d.ts

@@ -40,6 +40,7 @@ interface InitOptions {
     withWindsurf?: boolean;
     withContinuedev?: boolean;
     withAllPlatforms?: boolean;
+    withMcp?: boolean;
     withClaudeFlow?: boolean;
     skipClaudeFlow?: boolean;
     noGovernance?: boolean;

package/dist/cli/handlers/init-handler.js

@@ -49,6 +49,7 @@ export class InitHandler {
             .option('--with-codex', 'Include OpenAI Codex CLI MCP config and AGENTS.md')
             .option('--with-windsurf', 'Include Windsurf MCP config and rules')
             .option('--with-continuedev', 'Include Continue.dev MCP config and rules')
+            .option('--with-mcp', 'Include MCP server config in .mcp.json (opt-in — CLI works without MCP)')
             .option('--with-all-platforms', 'Include all coding agent platform configurations')
             .option('--auto-migrate', 'Automatically migrate from v2 if detected')
             .option('--with-claude-flow', 'Force Claude Flow integration setup')
@@ -114,6 +115,7 @@ export class InitHandler {
             withCodex: options.withCodex,
             withWindsurf: options.withWindsurf,
             withContinueDev: options.withContinuedev,
+            withMcp: options.withMcp,
             noGovernance: options.noGovernance,
         });
         console.log(chalk.white('  Analyzing project...\n'));
@@ -170,9 +172,14 @@ export class InitHandler {
             console.log(chalk.gray(`    - Claude Flow: ${cfResult?.available ? 'Enabled' : 'Standalone mode'}`));
             console.log(chalk.gray(`    - Total time: ${result.totalDurationMs}ms\n`));
             console.log(chalk.white('Next steps:'));
-            console.log(chalk.gray('  1. Add MCP: claude mcp add aqe -- aqe-mcp'));
-            console.log(chalk.gray('  2. Run tests: aqe test <path>'));
-            console.log(chalk.gray('  3. Check status: aqe status\n'));
+            console.log(chalk.gray('  1. Run tests: aqe test <path>'));
+            console.log(chalk.gray('  2. Check coverage: aqe coverage <path>'));
+            console.log(chalk.gray('  3. Check status: aqe status'));
+            if (!result.summary.mcpConfigured) {
+                console.log(chalk.gray('\n  Optional — enable MCP server for richer agent integration:'));
+                console.log(chalk.gray('    aqe init --with-mcp'));
+                console.log(chalk.gray('    # or manually: claude mcp add aqe -- aqe-mcp\n'));
+            }
         }
         else {
             console.log(chalk.red('  Initialization failed. Check errors above.\n'));
@@ -220,9 +227,14 @@ export class InitHandler {
             }
             console.log(chalk.gray(`    - Total time: ${result.totalDurationMs}ms\n`));
             console.log(chalk.white('Next steps:'));
-            console.log(chalk.gray('  1. Add MCP: claude mcp add aqe -- aqe-mcp'));
-            console.log(chalk.gray('  2. Run tests: aqe test <path>'));
-            console.log(chalk.gray('  3. Check status: aqe status\n'));
+            console.log(chalk.gray('  1. Run tests: aqe test <path>'));
+            console.log(chalk.gray('  2. Check coverage: aqe coverage <path>'));
+            console.log(chalk.gray('  3. Check status: aqe status'));
+            if (!result.summary.mcpConfigured) {
+                console.log(chalk.gray('\n  Optional — enable MCP server for richer agent integration:'));
+                console.log(chalk.gray('    aqe init --with-mcp'));
+                console.log(chalk.gray('    # or manually: claude mcp add aqe -- aqe-mcp\n'));
+            }
         }
         else {
             console.log(chalk.red('  Initialization failed. Check errors above.\n'));

package/dist/cli/index.js

@@ -816,6 +816,7 @@ import { createLLMRouterCommand } from './commands/llm-router.js';
 import { createSyncCommands } from './commands/sync.js';
 import { createHooksCommand } from './commands/hooks.js';
 import { createLearningCommand } from './commands/learning.js';
+import { createMemoryCommand } from './commands/memory.js';
 import { createMcpCommand } from './commands/mcp.js';
 import { createPlatformCommand } from './commands/platform.js';
 import { createProveCommand } from './commands/prove.js';
@@ -826,6 +827,7 @@ program.addCommand(createLLMRouterCommand());
 program.addCommand(createSyncCommands());
 program.addCommand(createHooksCommand());
 program.addCommand(createLearningCommand());
+program.addCommand(createMemoryCommand(context, cleanupAndExit, ensureInitialized));
 program.addCommand(createMcpCommand());
 program.addCommand(createPlatformCommand());
 program.addCommand(createProveCommand(context, cleanupAndExit, ensureInitialized));

package/dist/domains/code-intelligence/services/knowledge-graph.js

@@ -1041,6 +1041,7 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
             rs: 'rust',
             rb: 'ruby',
             cs: 'csharp',
+            swift: 'swift',
         };
         return typeMap[ext] || 'unknown';
     }
@@ -1052,6 +1053,8 @@ Return JSON: { "rankedIds": ["id1", "id2", ...], "insights": ["insight1", "insig
             go: ['go'],
             java: ['java'],
             rust: ['rs'],
+            csharp: ['cs'],
+            swift: ['swift'],
         };
         return languages.some((lang) => {
             const exts = langMap[lang.toLowerCase()] || [lang];

package/dist/domains/coverage-analysis/services/coverage-parser.d.ts

@@ -5,6 +5,12 @@
  * - LCOV format (from Istanbul, nyc, c8)
  * - Cobertura XML format
  * - JSON format (Istanbul/vitest)
+ * - JaCoCo XML format (Java/Kotlin)
+ * - dotcover XML format (C#/.NET)
+ * - Tarpaulin JSON format (Rust)
+ * - Go cover text format (Go)
+ * - Kover XML format (Kotlin/JVM)
+ * - xcresult JSON format (Swift/iOS)
  *
  * This is NOT a simulation - it reads and parses real coverage data.
  *
@@ -115,8 +121,10 @@ export interface FunctionDetail {
 export interface CoverageReport {
     /** Timestamp of when the report was generated */
     timestamp: Date;
-    /** Source format (lcov, cobertura, json) */
-    format: 'lcov' | 'cobertura' | 'json';
+    /** Source format */
+    format: CoverageFormat;
+    /** Detected source language (when determinable from format) */
+    language?: string;
     /** Coverage data by file */
     files: Map<string, FileCoverageData>;
     /** Summary statistics */
@@ -153,6 +161,10 @@ export interface CoverageSummary {
         percentage: number;
     };
 }
+/**
+ * Supported coverage format types
+ */
+export type CoverageFormat = 'lcov' | 'cobertura' | 'json' | 'jacoco' | 'dotcover' | 'tarpaulin' | 'gocover' | 'kover' | 'xcresult';
 /**
  * Parse LCOV format coverage data
  *
@@ -168,9 +180,65 @@ export declare function parseLCOVContent(content: string, projectRoot: string):
  */
 export declare function parseJSONCoverage(jsonPath: string, projectRoot?: string): Promise<CoverageReport>;
 /**
- * Auto-detect coverage format and parse accordingly
+ * Parse JaCoCo XML coverage data.
+ *
+ * JaCoCo XML structure:
+ *   <report><package><class><method><counter type="LINE" missed="X" covered="Y"/></method></class></package></report>
+ */
+export declare function parseJaCoCo(xmlPath: string, projectRoot?: string): Promise<CoverageReport>;
+export declare function parseJaCoCoContent(content: string, projectRoot: string): CoverageReport;
+/**
+ * Parse dotcover XML coverage data.
+ *
+ * dotcover XML structure:
+ *   <Root CoveredStatements="X" TotalStatements="Y"><Assembly><Namespace><Type><Member Statement="..."/></Type></Namespace></Assembly></Root>
+ */
+export declare function parseDotcover(xmlPath: string, projectRoot?: string): Promise<CoverageReport>;
+export declare function parseDotcoverContent(content: string, projectRoot: string): CoverageReport;
+/**
+ * Parse Tarpaulin JSON coverage data.
+ *
+ * Tarpaulin JSON structure (--output-dir with --out Json):
+ *   { "files": [ { "path": "...", "content": "...", "traces": [ { "line": N, "stats": { "Line": N } } ] } ] }
+ *
+ * Also handles tarpaulin LCOV output by delegating to parseLCOVContent.
+ */
+export declare function parseTarpaulin(filePath: string, projectRoot?: string): Promise<CoverageReport>;
+export declare function parseTarpaulinContent(content: string, projectRoot: string): CoverageReport;
+/**
+ * Parse Go coverage profile text format.
+ *
+ * Format:
+ *   mode: set|count|atomic
+ *   pkg/file.go:startLine.startCol,endLine.endCol numStatements count
+ */
+export declare function parseGoCover(coverPath: string, projectRoot?: string): Promise<CoverageReport>;
+export declare function parseGoCoverContent(content: string, projectRoot: string): CoverageReport;
+/**
+ * Parse Kover XML coverage data.
+ *
+ * Kover outputs JaCoCo-compatible XML. This delegates to the JaCoCo parser
+ * but sets the format and language appropriately.
+ */
+export declare function parseKover(xmlPath: string, projectRoot?: string): Promise<CoverageReport>;
+/**
+ * Parse xcresult coverage data exported via:
+ *   xcrun xccov view --report --json result.xcresult > coverage.json
+ *
+ * Structure:
+ *   { "targets": [ { "files": [ { "path": "...", "lineCoverage": 0.85, "coveredLines": N, "executableLines": N, "functions": [...] } ] } ] }
+ */
+export declare function parseXcresult(jsonPath: string, projectRoot?: string): Promise<CoverageReport>;
+export declare function parseXcresultContent(content: string, projectRoot: string): CoverageReport;
+/**
+ * Auto-detect coverage format and parse accordingly.
+ *
+ * @param coveragePath - Path to the coverage file
+ * @param projectRoot - Project root for relative path calculation
+ * @param format - Explicit format override
+ * @param language - Language hint for format inference
  */
-export declare function parseCoverage(coveragePath: string, projectRoot?: string): Promise<CoverageReport>;
+export declare function parseCoverage(coveragePath: string, projectRoot?: string, format?: CoverageFormat, language?: string): Promise<CoverageReport>;
 /**
  * Find and parse coverage files in a directory
  */