agentic-qe 3.10.7 → 3.10.9

package/dist/domains/code-intelligence/coordinator-hypergraph.js

@@ -20,10 +20,15 @@ export async function initializeHypergraph(hypergraphDbPath, enableGNN) {
     const path = await import('path');
     const { findProjectRoot } = await import('../../kernel/unified-memory.js');
     const projectRoot = findProjectRoot();
-    const dbPath = hypergraphDbPath || path.join(projectRoot, '.agentic-qe', 'memory.db');
-    const dir = path.dirname(dbPath);
-    if (!fs.existsSync(dir)) {
-        fs.mkdirSync(dir, { recursive: true });
+    // Database-free mode (#534): an ephemeral in-memory hypergraph DB, never the
+    // project's .agentic-qe/memory.db.
+    const inMemory = process.env.AQE_MEMORY_BACKEND === 'memory';
+    const dbPath = inMemory ? ':memory:' : (hypergraphDbPath || path.join(projectRoot, '.agentic-qe', 'memory.db'));
+    if (!inMemory) {
+        const dir = path.dirname(dbPath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
     }
     const db = openDatabase(dbPath);
     const engine = await createHypergraphEngine({

package/dist/domains/code-intelligence/coordinator.js

@@ -134,11 +134,16 @@ export class CodeIntelligenceCoordinator extends BaseDomainCoordinator {
             const path = await import('path');
             const { findProjectRoot } = await import('../../kernel/unified-memory.js');
             const projectRoot = findProjectRoot();
-            const dbPath = this.config.hypergraphDbPath || path.join(projectRoot, '.agentic-qe', 'memory.db');
+            // Database-free mode (#534): ephemeral in-memory hypergraph DB, never the
+            // project's .agentic-qe/memory.db.
+            const inMemory = process.env.AQE_MEMORY_BACKEND === 'memory';
+            const dbPath = inMemory ? ':memory:' : (this.config.hypergraphDbPath || path.join(projectRoot, '.agentic-qe', 'memory.db'));
             // Ensure directory exists
-            const dir = path.dirname(dbPath);
-            if (!fs.existsSync(dir)) {
-                fs.mkdirSync(dir, { recursive: true });
+            if (!inMemory) {
+                const dir = path.dirname(dbPath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
             }
             // Create database connection
             this.hypergraphDb = openDatabase(dbPath);

package/dist/init/cline-installer.d.ts

@@ -8,6 +8,11 @@
 export interface ClineInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface ClineInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface ClineInstallResult {
 export declare class ClineInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: ClineInstallerOptions);
     install(): Promise<ClineInstallResult>;

package/dist/init/cline-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class ClineInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class ClineInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('cline');
+            const mcpConfig = this.generator.generateMcpConfig('cline', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/init/codex-installer.d.ts

@@ -8,6 +8,11 @@
 export interface CodexInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface CodexInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface CodexInstallResult {
 export declare class CodexInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: CodexInstallerOptions);
     install(): Promise<CodexInstallResult>;

package/dist/init/codex-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class CodexInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class CodexInstaller {
         };
         try {
             // Generate TOML MCP config
-            const mcpConfig = this.generator.generateMcpConfig('codex');
+            const mcpConfig = this.generator.generateMcpConfig('codex', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/init/continuedev-installer.d.ts

@@ -8,6 +8,11 @@
 export interface ContinueDevInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface ContinueDevInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface ContinueDevInstallResult {
 export declare class ContinueDevInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: ContinueDevInstallerOptions);
     install(): Promise<ContinueDevInstallResult>;

package/dist/init/continuedev-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class ContinueDevInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class ContinueDevInstaller {
         };
         try {
             // Generate YAML MCP config
-            const mcpConfig = this.generator.generateMcpConfig('continuedev');
+            const mcpConfig = this.generator.generateMcpConfig('continuedev', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {
@@ -83,6 +85,12 @@ export class ContinueDevInstaller {
             // If existing config already has mcpServers key, append just the server entry
             // to avoid duplicate mcpServers keys (which produces invalid YAML)
             if (existing.includes('mcpServers:')) {
+                // #533: honor database-free mode on the merge path too — otherwise this
+                // hardcoded entry re-introduces AQE_MEMORY_PATH and the server recreates
+                // memory.db at runtime, defeating a --no-database install.
+                const envBlock = this.options.memoryBackend === 'memory'
+                    ? `      AQE_MEMORY_BACKEND: memory\n      AQE_V3_MODE: "true"`
+                    : `      AQE_MEMORY_PATH: .agentic-qe/memory.db\n      AQE_V3_MODE: "true"`;
                 const serverEntry = `  - name: agentic-qe
     command: npx
     args:
@@ -90,8 +98,7 @@ export class ContinueDevInstaller {
       - agentic-qe@latest
       - mcp
     env:
-      AQE_MEMORY_PATH: .agentic-qe/memory.db
-      AQE_V3_MODE: "true"`;
+${envBlock}`;
                 return existing.trimEnd() + '\n' + serverEntry + '\n';
             }
             // No existing mcpServers — append the full block

package/dist/init/copilot-installer.d.ts

@@ -8,6 +8,11 @@
 export interface CopilotInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface CopilotInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface CopilotInstallResult {
 export declare class CopilotInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: CopilotInstallerOptions);
     install(): Promise<CopilotInstallResult>;

package/dist/init/copilot-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class CopilotInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class CopilotInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('copilot');
+            const mcpConfig = this.generator.generateMcpConfig('copilot', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/init/cursor-installer.d.ts

@@ -8,6 +8,11 @@
 export interface CursorInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface CursorInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface CursorInstallResult {
 export declare class CursorInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: CursorInstallerOptions);
     install(): Promise<CursorInstallResult>;

package/dist/init/cursor-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class CursorInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class CursorInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('cursor');
+            const mcpConfig = this.generator.generateMcpConfig('cursor', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/init/kilocode-installer.d.ts

@@ -8,6 +8,11 @@
 export interface KiloCodeInstallerOptions {
     projectRoot: string;
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the MCP config
+     * is written to run in-memory (AQE_MEMORY_BACKEND=memory, no AQE_MEMORY_PATH). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface KiloCodeInstallResult {
     success: boolean;
@@ -20,6 +25,7 @@ export interface KiloCodeInstallResult {
 export declare class KiloCodeInstaller {
     private projectRoot;
     private overwrite;
+    private options;
     private generator;
     constructor(options: KiloCodeInstallerOptions);
     install(): Promise<KiloCodeInstallResult>;

package/dist/init/kilocode-installer.js

@@ -15,10 +15,12 @@ import { createPlatformConfigGenerator, } from './platform-config-generator.js';
 export class KiloCodeInstaller {
     projectRoot;
     overwrite;
+    options;
     generator;
     constructor(options) {
         this.projectRoot = options.projectRoot;
         this.overwrite = options.overwrite ?? false;
+        this.options = options;
         this.generator = createPlatformConfigGenerator();
     }
     async install() {
@@ -32,7 +34,7 @@ export class KiloCodeInstaller {
         };
         try {
             // Generate MCP config
-            const mcpConfig = this.generator.generateMcpConfig('kilocode');
+            const mcpConfig = this.generator.generateMcpConfig('kilocode', { memoryBackend: this.options.memoryBackend });
             const configPath = join(this.projectRoot, mcpConfig.path);
             result.configPath = configPath;
             if (!existsSync(configPath) || this.overwrite) {

package/dist/init/kiro-installer.d.ts

@@ -18,6 +18,11 @@ export interface KiroInstallerOptions {
     installSteering?: boolean;
     /** Overwrite existing files (default: false) */
     overwrite?: boolean;
+    /**
+     * Memory backend for this install. 'memory' => database-free: the Kiro MCP
+     * config runs the server in-memory (AQE_MEMORY_BACKEND=memory). (#533)
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface KiroInstallResult {
     success: boolean;

package/dist/init/kiro-installer.js

@@ -130,10 +130,10 @@ export class KiroInstaller {
                 'agentic-qe': {
                     command: 'npx',
                     args: ['-y', 'agentic-qe@latest', 'mcp'],
-                    env: {
-                        AQE_MEMORY_PATH: '.agentic-qe/memory.db',
-                        AQE_V3_MODE: 'true',
-                    },
+                    // Issue #533: database-free installs run the MCP server in-memory.
+                    env: this.options.memoryBackend === 'memory'
+                        ? { AQE_MEMORY_BACKEND: 'memory', AQE_V3_MODE: 'true' }
+                        : { AQE_MEMORY_PATH: '.agentic-qe/memory.db', AQE_V3_MODE: 'true' },
                     disabled: false,
                     autoApprove: [
                         'fleet_init',

package/dist/init/opencode-installer.d.ts

@@ -2,8 +2,20 @@
  * OpenCode Platform Installer
  * ADR-025: Enhanced Init with Self-Configuration
  *
- * Installs OpenCode agents, skills, tools, and permissions to user projects
- * when --with-opencode flag is used. Follows the N8n installer pattern.
+ * Installs OpenCode agents and skills to user projects in OpenCode's NATIVE
+ * on-disk format (validated against OpenCode CLI v1.17.x):
+ *   - agents -> .opencode/agent/<name>.md   (markdown + YAML frontmatter; body = system prompt)
+ *   - skills -> .opencode/skills/<name>/SKILL.md  (frontmatter name+description; body = instructions)
+ *   - MCP    -> opencode.json (mcp.agentic-qe local server)
+ *
+ * The shipped source assets under <pkg>/.opencode/{agents,skills} use AQE's own
+ * YAML schema (name/description/model/systemPrompt/tools/permissions). OpenCode
+ * does NOT load that schema, so this installer CONVERTS them at install time.
+ *
+ * Tools are intentionally NOT installed: AQE's .opencode/tools/*.ts use a custom
+ * `{name, parameters, execute}` shape and call ctx.callTool('mcp:agentic-qe:*'),
+ * which is incompatible with OpenCode's `tool()` API and redundant once the MCP
+ * server is connected (the underlying tools are exposed directly).
  */
 export interface OpenCodeInstallerOptions {
     /** Project root directory */
@@ -12,10 +24,21 @@ export interface OpenCodeInstallerOptions {
     installAgents?: boolean;
     /** Install OpenCode skill definitions (default: true) */
     installSkills?: boolean;
-    /** Install OpenCode tool wrappers (default: true) */
+    /**
+     * Install AQE tool wrappers. Default false — AQE's tool .ts files are not in
+     * OpenCode's `tool()` format and are redundant with the MCP server. Kept as an
+     * option only for backward compatibility; enabling it copies incompatible files.
+     */
     installTools?: boolean;
     /** Overwrite existing files (default: false) */
     overwrite?: boolean;
+    /**
+     * Memory backend the generated opencode.json MCP server should use at runtime.
+     * 'memory' => fully database-free install: AQE_MEMORY_BACKEND=memory and no
+     * AQE_MEMORY_PATH, so the MCP server keeps everything in-memory and writes
+     * nothing under .agentic-qe/. Default (undefined) preserves persistent SQLite.
+     */
+    memoryBackend?: 'memory' | 'sqlite' | 'agentdb' | 'hybrid';
 }
 export interface OpenCodeInstallResult {
     success: boolean;
@@ -32,7 +55,7 @@ export declare class OpenCodeInstaller {
     private sourceDir;
     constructor(options: OpenCodeInstallerOptions);
     /**
-     * Find the source .opencode/ directory containing agents/skills/tools to install.
+     * Find the source .opencode/ directory containing agents/skills to install.
      * Resolves relative to the package installation directory (not CWD) so that
      * globally-installed and bundled CLI paths all work correctly (#361).
      */
@@ -43,27 +66,26 @@ export declare class OpenCodeInstaller {
      */
     private isValidSourceDir;
     /**
-     * Install OpenCode agents, skills, tools, and permissions
+     * Install OpenCode agents, skills, and MCP config (native OpenCode format).
      */
     install(): Promise<OpenCodeInstallResult>;
     /**
-     * Install agent YAML files from .opencode/agents/
+     * Load the shipped permissions.yaml (defaults + per-agent overrides). Returns
+     * { defaults, agents } or empty maps if the file is missing/unparseable.
      */
-    private installAgents;
+    private loadPermissionsYaml;
     /**
-     * Install skill YAML files from .opencode/skills/
+     * Build an OpenCode-valid `permission` frontmatter object by merging
+     * defaults -> agent.permissions (from agent yaml) -> permissions.yaml override,
+     * remapping keys and dropping anything OpenCode does not understand.
      */
+    private buildPermission;
+    private installAgents;
     private installSkills;
+    /** Render a frontmatter object as a `---`-delimited YAML block. */
+    private renderFrontmatter;
     /**
-     * Install tool wrapper files from .opencode/tools/
-     */
-    private installTools;
-    /**
-     * Install permissions.yaml to target .opencode/ directory
-     */
-    private installPermissions;
-    /**
-     * Generate opencode.json MCP config if it does not already exist
+     * Generate opencode.json MCP config if it does not already exist.
      */
     private generateOpenCodeConfig;
 }