feat(cli): support project-configured memory db path

Author: codeaholicguy

docs/ai/implementation/feature-memory-db-path-config.md

@@ -12,29 +12,29 @@ description: Implementation notes for project-configurable memory database paths
 
 ## Code Structure
 - Config shape and parsing live in the CLI package.
-- Effective database path selection must be shared by all memory entry points.
+- Effective database path selection is resolved in the CLI and passed explicitly into the memory package.
 
 ## Implementation Notes
 ### Core Features
 - Add typed support for `memory.path` in project config.
 - Resolve relative configured paths from the project root.
-- Pass the resolved path into every memory operation entry point.
+- Pass the resolved path into `ai-devkit memory store`, `search`, and `update`.
 
 ### Patterns & Best Practices
 - Keep `DEFAULT_DB_PATH` as the fallback constant.
-- Avoid duplicating path-resolution logic across command handlers and server code.
+- Avoid duplicating path-resolution logic across CLI command handlers.
 
 ## Integration Points
 - `.ai-devkit.json`
 - `ConfigManager`
 - memory CLI command adapters
-- memory MCP server
 
 ## Error Handling
 - Invalid or absent `memory.path` should not break memory commands; fall back to the default path.
 
 ## Performance Considerations
-- Path resolution should happen once per command/tool invocation before opening the database.
+- Path resolution should happen once per CLI command invocation before opening the database.
 
 ## Security Notes
 - Treat `memory.path` as a filesystem path only; no shell execution or interpolation.
+- Standalone `@ai-devkit/memory` server behavior remains unchanged in this feature.

docs/ai/planning/feature-memory-db-path-config.md

@@ -7,31 +7,31 @@ description: Task breakdown for project-configurable memory database paths
 # Project Planning & Task Breakdown
 
 ## Milestones
-- [ ] Milestone 1: Project config schema and parsing support `memory.path`
-- [ ] Milestone 2: Memory command and server flows consume resolved database path
-- [ ] Milestone 3: Tests cover configured path and fallback behavior
+- [x] Milestone 1: Project config schema and parsing support `memory.path`
+- [x] Milestone 2: CLI memory command flows consume resolved database path
+- [x] Milestone 3: Tests cover configured path and fallback behavior
 
 ## Task Breakdown
 
 ### Phase 1: Config Support
-- [ ] Task 1.1: Extend `packages/cli/src/types.ts` to type optional `memory.path`
-- [ ] Task 1.2: Add `ConfigManager.getMemoryDbPath()` in `packages/cli/src/lib/Config.ts`
-- [ ] Task 1.3: Add unit tests for project config parsing, including missing, invalid, absolute, and relative path cases
+- [x] Task 1.1: Extend `packages/cli/src/types.ts` to type optional `memory.path`
+- [x] Task 1.2: Add `ConfigManager.getMemoryDbPath()` in `packages/cli/src/lib/Config.ts`
+- [x] Task 1.3: Add unit tests for project config parsing, including missing, invalid, absolute, and relative path cases
 
 ### Phase 2: Memory Path Wiring
-- [ ] Task 2.1: Introduce a shared path-resolution flow that combines project config override with `DEFAULT_DB_PATH`
-- [ ] Task 2.2: Update `packages/memory/src/api.ts` and related entry points so store/search/update use the resolved path consistently
-- [ ] Task 2.3: Update the memory MCP server startup/tool handling to honor the same project-configured database path
+- [x] Task 2.1: Introduce a CLI-owned path-resolution flow that combines project config override with `DEFAULT_DB_PATH`
+- [x] Task 2.2: Update `packages/memory/src/api.ts` and CLI entry points so store/search/update use the resolved path consistently
+- [x] Task 2.3: Removed from scope during Phase 2 review. Standalone `@ai-devkit/memory` MCP server remains unchanged for this feature.
 
 ### Phase 3: Verification
-- [ ] Task 3.1: Add or update CLI tests covering memory commands with configured `memory.path`
-- [ ] Task 3.2: Add or update memory package tests covering fallback to `~/.ai-devkit/memory.db`
-- [ ] Task 3.3: Run targeted verification for docs lint and relevant automated tests
+- [x] Task 3.1: Add or update CLI tests covering memory commands with configured `memory.path`
+- [x] Task 3.2: Add or update memory package tests covering explicit `dbPath` wiring and configured-path persistence
+- [x] Task 3.3: Run targeted verification for docs lint and relevant automated tests
 
 ## Dependencies
 - Task 1.1 precedes Task 1.2 because config typing should match the new parser surface.
 - Task 1.2 precedes Task 2.1 and Task 2.2 because runtime resolution depends on the config accessor.
-- Task 2.1 should land before Task 2.2 and Task 2.3 so all memory entry points share one resolution rule.
+- Task 2.1 should land before Task 2.2 so CLI and memory API use one resolution rule.
 - Verification tasks depend on both config support and runtime wiring being complete.
 
 ## Timeline & Estimates
@@ -40,8 +40,8 @@ description: Task breakdown for project-configurable memory database paths
 - Phase 3: Small to medium effort depending on current test coverage for memory command setup
 
 ## Risks & Mitigation
-- Risk: CLI commands honor config but MCP server still uses the default database.
-  Mitigation: Define one shared resolver and cover both entry points in tests.
+- Risk: CLI commands honor config but the standalone MCP server still uses the default database.
+  Mitigation: This is intentional and documented as out of scope for the feature.
 - Risk: Relative paths resolve from process cwd instead of project root.
   Mitigation: Resolve from the config file directory and add explicit unit tests.
 - Risk: Invalid config values break existing users.
@@ -51,3 +51,8 @@ description: Task breakdown for project-configurable memory database paths
 - Existing config loading utilities in `packages/cli/src/lib/Config.ts`
 - Existing database connection behavior in `packages/memory/src/database/connection.ts`
 - Existing memory command tests in `packages/cli/src/__tests__/commands/memory.test.ts`
+
+## Progress Summary
+- Completed implementation for project-configured `memory.path` in `ai-devkit` CLI flows.
+- Preserved standalone `@ai-devkit/memory` behavior as approved during requirements review.
+- Verified with targeted CLI tests, memory integration tests, feature doc lint, package builds, and a real built-CLI store/search run against a temporary project config.

docs/ai/testing/feature-memory-db-path-config.md

@@ -9,39 +9,53 @@ description: Testing plan for project-configurable memory database paths
 ## Test Coverage Goals
 - Cover 100% of new and changed code related to config parsing and path resolution.
 - Verify both configured-path and default-path flows.
+- Keep standalone `@ai-devkit/memory` server behavior unchanged.
 
 ## Unit Tests
 ### Config parsing
-- [ ] Reads `memory.path` when it is a non-empty string
-- [ ] Ignores missing, blank, and non-string `memory.path`
-- [ ] Resolves relative `memory.path` from the project config directory
+- [x] Reads `memory.path` when it is a non-empty string
+- [x] Ignores missing, blank, and non-string `memory.path`
+- [x] Resolves relative `memory.path` from the project config directory
+  Implemented in `packages/cli/src/__tests__/lib/Config.test.ts`
 
 ### Memory command resolution
-- [ ] `memory store` uses configured path when project config exists
-- [ ] `memory search` uses configured path when project config exists
-- [ ] `memory update` uses configured path when project config exists
-- [ ] Commands fall back to `~/.ai-devkit/memory.db` when no project override exists
+- [x] `memory store` uses configured path when project config exists
+- [x] `memory search` uses configured path when project config exists
+- [x] `memory update` uses configured path when project config exists
+- [x] Commands fall back to `~/.ai-devkit/memory.db` when no project override exists
+  Verified by default `dbPath: undefined` expectations and configured-path expectations in `packages/cli/src/__tests__/commands/memory.test.ts`
 
 ## Integration Tests
-- [ ] Memory MCP server tool calls use the same resolved path as CLI commands
-- [ ] Schema initialization still succeeds when the configured path points to a new file
+- [x] Schema initialization succeeds when the configured path points to a new file
+- [x] Memory API store/search/update calls use an explicit configured `dbPath`
+  Implemented in `packages/memory/tests/integration/api.test.ts`
+- [x] Standalone memory MCP server remains out of scope and unchanged
+  Covered by design/requirements scope, not by new behavior tests
 
 ## End-to-End Tests
-- [ ] Manual smoke test with a checked-in `.ai-devkit.json` using a repo-local memory DB
+- [x] Automated CLI e2e test uses a temp-project `.ai-devkit.json` with repo-local `memory.path`
+  Implemented in `e2e/cli.e2e.ts`
+- [x] Manual smoke test with a checked-in `.ai-devkit.json` using a repo-local memory DB
+  Verified via built CLI store/search run in a temporary project directory with `.ai-devkit.json` pointing to `.ai-devkit/project-memory.db`
 
 ## Test Data
 - Temporary project directories with generated `.ai-devkit.json`
 - Temporary database file paths for isolated runs
 
 ## Test Reporting & Coverage
-- Run targeted CLI and memory package tests plus docs lint for this feature
+- Ran `npm test -- --runInBand Config.test.ts memory.test.ts` in `packages/cli`
+- Ran `npm test -- --runInBand tests/integration/api.test.ts` in `packages/memory`
+- Ran `npm run test:e2e -- cli.e2e.ts`
+- Ran `npx ai-devkit@latest lint --feature memory-db-path-config`
+- Did not run a full coverage report command in this phase; targeted suites were used for feature verification
 
 ## Manual Testing
-- Confirm a repo-local configured DB file is created on first write
-- Confirm commands revert to the home-directory database when config is removed
+- Confirmed a repo-local configured DB file is created on first write
+- Confirmed built CLI search reads back from the configured repo-local DB
+- Default fallback is covered by unit tests rather than a separate manual run
 
 ## Performance Testing
 - No dedicated performance testing required beyond regression confidence
 
 ## Bug Tracking
-- Watch for regressions where one memory entry point still opens `~/.ai-devkit/memory.db`
+- Watch for regressions where one CLI memory subcommand omits `dbPath` and reverts to `~/.ai-devkit/memory.db`

e2e/cli.e2e.ts

@@ -148,10 +148,22 @@ describe('lint command', () => {
 describe('memory commands', () => {
   let projectDir: string;
   let uid: string;
+  let projectMemoryDbPath: string;
 
   beforeEach(() => {
     projectDir = createTempProject();
     uid = `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    projectMemoryDbPath = join(projectDir, '.ai-devkit', 'memory.db');
+    writeConfigFile(projectDir, {
+      version: '1.0.0',
+      environments: [],
+      phases: [],
+      memory: {
+        path: '.ai-devkit/memory.db'
+      },
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    });
   });
 
   afterEach(() => {
@@ -168,6 +180,7 @@ describe('memory commands', () => {
     const stored = JSON.parse(storeResult.stdout.trim());
     expect(stored.success).toBe(true);
     expect(stored.id).toBeDefined();
+    expect(existsSync(projectMemoryDbPath)).toBe(true);
 
     const searchResult = run(`memory search -q "${title}"`, { cwd: projectDir });
     expect(searchResult.exitCode).toBe(0);

packages/cli/src/__tests__/commands/memory.test.ts

@@ -4,10 +4,19 @@ import { registerMemoryCommand } from '../../commands/memory';
 import { memorySearchCommand, memoryStoreCommand, memoryUpdateCommand } from '@ai-devkit/memory';
 import { ui } from '../../util/terminal-ui';
 
+const mockGetMemoryDbPath = jest.fn<() => Promise<string | undefined>>();
+const mockConfigManager = {
+  getMemoryDbPath: mockGetMemoryDbPath
+};
+
 jest.mock('@ai-devkit/memory', () => ({
   memoryStoreCommand: jest.fn(),
   memorySearchCommand: jest.fn(),
   memoryUpdateCommand: jest.fn()
+}), { virtual: true });
+
+jest.mock('../../lib/Config', () => ({
+  ConfigManager: jest.fn(() => mockConfigManager)
 }));
 
 jest.mock('../../util/terminal-ui', () => ({
@@ -27,6 +36,7 @@ describe('memory command', () => {
 
   beforeEach(() => {
     jest.clearAllMocks();
+    mockGetMemoryDbPath.mockResolvedValue(undefined);
     consoleLogSpy = jest.spyOn(console, 'log').mockImplementation(() => undefined);
   });
 
@@ -51,10 +61,42 @@ describe('memory command', () => {
       'This is a valid content body long enough to satisfy constraints.'
     ]);
 
-    expect(mockedMemoryStoreCommand).toHaveBeenCalled();
+    expect(mockedMemoryStoreCommand).toHaveBeenCalledWith({
+      title: 'A valid title 123',
+      content: 'This is a valid content body long enough to satisfy constraints.',
+      tags: undefined,
+      scope: 'global',
+      dbPath: undefined
+    });
     expect(consoleLogSpy).toHaveBeenCalledWith(JSON.stringify(result, null, 2));
   });
 
+  it('passes resolved project dbPath to memory store', async () => {
+    mockGetMemoryDbPath.mockResolvedValue('/repo/.ai-devkit/project-memory.db');
+    mockedMemoryStoreCommand.mockReturnValue({
+      success: true,
+      id: 'mem-1',
+      message: 'stored'
+    });
+
+    const program = new Command();
+    registerMemoryCommand(program);
+    await program.parseAsync([
+      'node',
+      'test',
+      'memory',
+      'store',
+      '--title',
+      'A valid title 123',
+      '--content',
+      'This is a valid content body long enough to satisfy constraints.'
+    ]);
+
+    expect(mockedMemoryStoreCommand).toHaveBeenCalledWith(expect.objectContaining({
+      dbPath: '/repo/.ai-devkit/project-memory.db'
+    }));
+  });
+
   it('handles store errors by showing error and exiting', async () => {
     mockedMemoryStoreCommand.mockImplementation(() => {
       throw new Error('store failed');
@@ -104,7 +146,14 @@ describe('memory command', () => {
       'Updated title for testing',
     ]);
 
-    expect(mockedMemoryUpdateCommand).toHaveBeenCalled();
+    expect(mockedMemoryUpdateCommand).toHaveBeenCalledWith({
+      id: 'mem-1',
+      title: 'Updated title for testing',
+      content: undefined,
+      tags: undefined,
+      scope: undefined,
+      dbPath: undefined
+    });
     expect(consoleLogSpy).toHaveBeenCalledWith(JSON.stringify(result, null, 2));
   });
 
@@ -161,7 +210,8 @@ describe('memory command', () => {
       query: 'dto',
       tags: undefined,
       scope: undefined,
-      limit: 5
+      limit: 5,
+      dbPath: undefined
     });
     expect(consoleLogSpy).toHaveBeenCalledWith(JSON.stringify(result, null, 2));
     expect(mockedUi.table).not.toHaveBeenCalled();
@@ -191,7 +241,8 @@ describe('memory command', () => {
       query: 'memory',
       tags: undefined,
       scope: undefined,
-      limit: 3
+      limit: 3,
+      dbPath: undefined
     });
     expect(mockedUi.table).toHaveBeenCalledWith({
       headers: ['id', 'title', 'scope'],
@@ -200,6 +251,36 @@ describe('memory command', () => {
     expect(consoleLogSpy).not.toHaveBeenCalledWith(expect.stringContaining('"results"'));
   });
 
+  it('passes resolved project dbPath to memory search and update', async () => {
+    mockGetMemoryDbPath.mockResolvedValue('/repo/.ai-devkit/project-memory.db');
+    mockedMemorySearchCommand.mockReturnValue({
+      results: [],
+      totalMatches: 0,
+      query: 'dto'
+    });
+    mockedMemoryUpdateCommand.mockReturnValue({
+      success: true,
+      id: 'mem-1',
+      message: 'Knowledge updated successfully'
+    });
+
+    let program = new Command();
+    registerMemoryCommand(program);
+    await program.parseAsync(['node', 'test', 'memory', 'search', '--query', 'dto']);
+
+    expect(mockedMemorySearchCommand).toHaveBeenCalledWith(expect.objectContaining({
+      dbPath: '/repo/.ai-devkit/project-memory.db'
+    }));
+
+    program = new Command();
+    registerMemoryCommand(program);
+    await program.parseAsync(['node', 'test', 'memory', 'update', '--id', 'mem-1', '--title', 'Updated title for testing']);
+
+    expect(mockedMemoryUpdateCommand).toHaveBeenCalledWith(expect.objectContaining({
+      dbPath: '/repo/.ai-devkit/project-memory.db'
+    }));
+  });
+
   it('shows a warning when --table has no matching results', async () => {
     mockedMemorySearchCommand.mockReturnValue({
       results: [],