agentic-qe 3.8.6 → 3.8.8

package/dist/cli/command-registry.js

@@ -4,7 +4,7 @@
  * Central registry for all CLI command handlers.
  * Provides command routing and management.
  */
-import { createInitHandler, createStatusHandler, createHealthHandler, createTaskHandler, createAgentHandler, createDomainHandler, createProtocolHandler, createBrainHandler, } from './handlers/index.js';
+import { createInitHandler, createStatusHandler, createHealthHandler, createTaskHandler, createAgentHandler, createDomainHandler, createProtocolHandler, createBrainHandler, createHypergraphHandler, } from './handlers/index.js';
 // ============================================================================
 // Command Registry
 // ============================================================================
@@ -80,6 +80,8 @@ export class CommandRegistry {
         this.register(createProtocolHandler(this.cleanupAndExit, this.ensureInitialized));
         // Brain export/import
         this.register(createBrainHandler(this.cleanupAndExit, this.ensureInitialized));
+        // Hypergraph queries
+        this.register(createHypergraphHandler(this.cleanupAndExit, this.ensureInitialized));
     }
     /**
      * Get help for all commands

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/completions/index.d.ts

@@ -115,6 +115,23 @@ export declare const COMMANDS: {
         readonly description: "V2 to V3 migration";
         readonly options: readonly ["--dry-run", "--backup", "--skip-memory", "--skip-patterns", "--skip-config", "--force"];
     };
+    readonly hypergraph: {
+        readonly description: "Query the code knowledge hypergraph";
+        readonly subcommands: {
+            readonly stats: {
+                readonly options: readonly ["--db"];
+            };
+            readonly untested: {
+                readonly options: readonly ["--db", "--limit"];
+            };
+            readonly impacted: {
+                readonly options: readonly ["--db"];
+            };
+            readonly gaps: {
+                readonly options: readonly ["--db", "--max-coverage", "--limit"];
+            };
+        };
+    };
     readonly completions: {
         readonly description: "Generate shell completions";
         readonly subcommands: {

package/dist/cli/completions/index.js

@@ -210,6 +210,16 @@ export const COMMANDS = {
         description: 'V2 to V3 migration',
         options: ['--dry-run', '--backup', '--skip-memory', '--skip-patterns', '--skip-config', '--force'],
     },
+    // Hypergraph queries
+    hypergraph: {
+        description: 'Query the code knowledge hypergraph',
+        subcommands: {
+            stats: { options: ['--db'] },
+            untested: { options: ['--db', '--limit'] },
+            impacted: { options: ['--db'] },
+            gaps: { options: ['--db', '--max-coverage', '--limit'] },
+        },
+    },
     // Completions command (meta)
     completions: {
         description: 'Generate shell completions',
@@ -315,7 +325,7 @@ _aqe_completions() {
     local cur prev words cword
     _init_completion || return
 
-    local commands="init status health task agent domain protocol test coverage quality security code migrate completions"
+    local commands="init status health task agent domain protocol test coverage quality security code migrate hypergraph completions"
     local task_subcmds="submit list cancel status"
     local agent_subcmds="list spawn"
     local domain_subcmds="list health"
@@ -614,6 +624,23 @@ _aqe_completions() {
                     ;;
             esac
             ;;
+        hypergraph)
+            local hg_subcmds="stats untested impacted gaps"
+            case "\${words[2]}" in
+                stats|untested|gaps)
+                    COMPREPLY=( $(compgen -W "--db --limit --max-coverage" -- "$cur") )
+                    return
+                    ;;
+                impacted)
+                    COMPREPLY=( $(compgen -f -- "$cur") )
+                    return
+                    ;;
+                *)
+                    COMPREPLY=( $(compgen -W "$hg_subcmds" -- "$cur") )
+                    return
+                    ;;
+            esac
+            ;;
         migrate)
             COMPREPLY=( $(compgen -W "--dry-run --backup --skip-memory --skip-patterns --skip-config --force" -- "$cur") )
             return
@@ -692,6 +719,7 @@ _aqe() {
         'quality:Quality assessment'
         'security:Security scanning'
         'code:Code intelligence'
+        'hypergraph:Query the code knowledge hypergraph'
         'migrate:V2 to V3 migration'
         'completions:Generate shell completions'
     )
@@ -939,6 +967,20 @@ _aqe() {
                         '--depth[Analysis depth]:depth:(1 2 3 4 5)' \\
                         '--include-tests[Include test files]'
                     ;;
+                hypergraph)
+                    local -a hg_commands
+                    hg_commands=(
+                        'stats:Show hypergraph statistics'
+                        'untested:Find untested functions'
+                        'impacted:Find impacted tests'
+                        'gaps:Find coverage gaps'
+                    )
+                    _arguments -C \\
+                        '1:command:_describe command hg_commands' \\
+                        '--db[Database path]:path:_files' \\
+                        '--limit[Max results]:number:' \\
+                        '--max-coverage[Coverage threshold]:number:'
+                    ;;
                 migrate)
                     _arguments \\
                         '--dry-run[Preview migration without changes]' \\
@@ -1015,6 +1057,11 @@ complete -c aqe -n "__fish_use_subcommand" -a "coverage" -d "Coverage analysis"
 complete -c aqe -n "__fish_use_subcommand" -a "quality" -d "Quality assessment"
 complete -c aqe -n "__fish_use_subcommand" -a "security" -d "Security scanning"
 complete -c aqe -n "__fish_use_subcommand" -a "code" -d "Code intelligence"
+complete -c aqe -n "__fish_use_subcommand" -a "hypergraph" -d "Query the code knowledge hypergraph"
+complete -c aqe -n "__fish_seen_subcommand_from hypergraph; and not __fish_seen_subcommand_from stats untested impacted gaps" -a "stats" -d "Show hypergraph statistics"
+complete -c aqe -n "__fish_seen_subcommand_from hypergraph; and not __fish_seen_subcommand_from stats untested impacted gaps" -a "untested" -d "Find untested functions"
+complete -c aqe -n "__fish_seen_subcommand_from hypergraph; and not __fish_seen_subcommand_from stats untested impacted gaps" -a "impacted" -d "Find impacted tests"
+complete -c aqe -n "__fish_seen_subcommand_from hypergraph; and not __fish_seen_subcommand_from stats untested impacted gaps" -a "gaps" -d "Find coverage gaps"
 complete -c aqe -n "__fish_use_subcommand" -a "migrate" -d "V2 to V3 migration"
 complete -c aqe -n "__fish_use_subcommand" -a "completions" -d "Generate shell completions"
 
@@ -1217,6 +1264,7 @@ $script:AQE_COMMANDS = @{
     'quality' = 'Quality assessment'
     'security' = 'Security scanning'
     'code' = 'Code intelligence'
+    'hypergraph' = 'Query the code knowledge hypergraph'
     'migrate' = 'V2 to V3 migration'
     'completions' = 'Generate shell completions'
 }

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

@@ -0,0 +1,27 @@
+/**
+ * Agentic QE v3 - Hypergraph Command Handler
+ *
+ * Exposes hypergraph queries to users via CLI:
+ *   aqe hypergraph stats       - Show node/edge counts by type
+ *   aqe hypergraph untested    - Find functions with no test coverage
+ *   aqe hypergraph impacted    - Find tests impacted by changed files
+ *   aqe hypergraph gaps        - Find functions with low coverage
+ */
+import { Command } from 'commander';
+import { ICommandHandler, CLIContext } from './interfaces.js';
+export declare class HypergraphHandler implements ICommandHandler {
+    readonly name = "hypergraph";
+    readonly description = "Query the code knowledge hypergraph";
+    private cleanupAndExit;
+    private ensureInitialized;
+    constructor(cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>);
+    register(program: Command, _context: CLIContext): void;
+    private executeStats;
+    private executeUntested;
+    private executeImpacted;
+    private executeGaps;
+    private openEngine;
+    getHelp(): string;
+}
+export declare function createHypergraphHandler(cleanupAndExit: (code: number) => Promise<never>, ensureInitialized: () => Promise<boolean>): HypergraphHandler;
+//# sourceMappingURL=hypergraph-handler.d.ts.map