@yeseh/cortex-cli 0.6.0 → 0.6.4

package/src/store/commands/init.spec.ts

@@ -12,28 +12,25 @@ import { join } from 'node:path';
 import type { PromptDeps } from '../../utils/prompts.ts';
 
 import { handleInit } from './init.ts';
-import {
-    createMockContext,
-    createMockStorageAdapter,
-    captureOutput,
-} from '../../test-helpers.spec.ts';
-
-// Produce a store adapter whose `stores.load` reports NOT_FOUND (so the new
-// store can be created) and `stores.save` succeeds.
-function createInitAdapter() {
-    return createMockStorageAdapter({
-        config: {
-            path: '/tmp/cortex-test-config.yaml',
-            data: null,
-            stores: null,
-            settings: null,
-            initializeConfig: async () => ({ ok: () => true as const, value: undefined }),
-            getSettings: async () => ({ ok: () => true as const, value: {} }),
-            getStores: async () => ({ ok: () => true as const, value: {} }),
-            getStore: async () => ({ ok: () => true as const, value: null }),
-            saveStore: async () => ({ ok: () => true as const, value: undefined }),
-        } as any,
-    });
+import { createMockContext, captureOutput } from '../../test-helpers.spec.ts';
+import { FilesystemConfigAdapter } from '@yeseh/cortex-storage-fs';
+
+/**
+ * Creates a real FilesystemConfigAdapter backed by a temp config file and
+ * injects it into a mock context so handleInit can construct a real
+ * FilesystemStorageAdapter without the adapter factory throwing STORE_NOT_FOUND.
+ */
+async function createInitContext(tempDir: string) {
+    const configPath = join(tempDir, 'config.yaml');
+    const configAdapter = new FilesystemConfigAdapter(configPath);
+    await configAdapter.initializeConfig();
+
+    const { ctx, stdout, stdin } = createMockContext({ cwd: tempDir });
+    // Replace the mock ConfigAdapter with a real one so FilesystemStorageAdapter
+    // construction inside handleInit works correctly.
+    (ctx as unknown as Record<string, unknown>).config = configAdapter;
+
+    return { ctx, stdout, stdin };
 }
 
 describe('handleInit', () => {
@@ -48,10 +45,7 @@ describe('handleInit', () => {
     });
 
     it('should initialize a store and write success message to stdout', async () => {
-        const { ctx, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdout } = await createInitContext(tempDir);
 
         await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' });
 
@@ -61,10 +55,7 @@ describe('handleInit', () => {
 
     it('should use the provided target path as the store path', async () => {
         const customPath = join(tempDir, 'custom-store');
-        const { ctx, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdout } = await createInitContext(tempDir);
 
         await handleInit(ctx, customPath, { name: 'my-project', format: 'yaml' });
 
@@ -73,10 +64,7 @@ describe('handleInit', () => {
     });
 
     it('should default to .cortex under cwd when no target path is given', async () => {
-        const { ctx, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdout } = await createInitContext(tempDir);
 
         await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' });
 
@@ -86,10 +74,7 @@ describe('handleInit', () => {
     });
 
     it('should throw InvalidArgumentError for an invalid store name', async () => {
-        const { ctx } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx } = await createInitContext(tempDir);
 
         await expect(handleInit(ctx, undefined, { name: '   ', format: 'yaml' })).rejects.toThrow(
             InvalidArgumentError,
@@ -97,10 +82,7 @@ describe('handleInit', () => {
     });
 
     it('should output in JSON format when format option is json', async () => {
-        const { ctx, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdout } = await createInitContext(tempDir);
 
         await handleInit(ctx, undefined, { name: 'my-project', format: 'json' });
 
@@ -111,10 +93,7 @@ describe('handleInit', () => {
     });
 
     it('should include the store name in the success output', async () => {
-        const { ctx, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdout } = await createInitContext(tempDir);
 
         await handleInit(ctx, undefined, { name: 'hello-world', format: 'json' });
 
@@ -124,10 +103,7 @@ describe('handleInit', () => {
     });
 
     it('should expand tilde in target path', async () => {
-        const { ctx, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdout } = await createInitContext(tempDir);
 
         // resolveUserPath expands ~ — we just verify it doesn't throw and
         // produces output with a home-like absolute path
@@ -136,6 +112,19 @@ describe('handleInit', () => {
         const out = captureOutput(stdout);
         expect(out).toContain('my-store');
     });
+
+    it('should fail when the store name already exists', async () => {
+        const { ctx } = await createInitContext(tempDir);
+        const storePath = join(tempDir, '.cortex');
+
+        await handleInit(ctx, storePath, { name: 'duplicate-store', format: 'yaml' });
+
+        // Second init with the same name should throw
+        const { ctx: ctx2 } = await createInitContext(tempDir);
+        await expect(
+            handleInit(ctx2, join(tempDir, '.cortex2'), { name: 'duplicate-store', format: 'yaml' }),
+        ).rejects.toThrow();
+    });
 });
 
 describe('handleInit - interactive mode', () => {
@@ -150,13 +139,12 @@ describe('handleInit - interactive mode', () => {
     });
 
     it('should call promptDeps.input once (path only) when stdin is a TTY and --name is explicitly given', async () => {
-        const inputMock = mock(async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value');
+        const inputMock = mock(
+            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
+        );
         const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
 
-        const { ctx, stdin } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdin } = await createInitContext(tempDir);
         (stdin as unknown as { isTTY: boolean }).isTTY = true;
 
         await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' }, promptDeps);
@@ -167,13 +155,12 @@ describe('handleInit - interactive mode', () => {
     });
 
     it('should call promptDeps.input twice (name + path) when stdin is a TTY and no --name given', async () => {
-        const inputMock = mock(async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value');
+        const inputMock = mock(
+            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
+        );
         const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
 
-        const { ctx, stdin } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdin } = await createInitContext(tempDir);
         (stdin as unknown as { isTTY: boolean }).isTTY = true;
 
         // No --name provided, should prompt for both name and path
@@ -183,13 +170,12 @@ describe('handleInit - interactive mode', () => {
     });
 
     it('should NOT call promptDeps.input when stdin is NOT a TTY', async () => {
-        const inputMock = mock(async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value');
+        const inputMock = mock(
+            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
+        );
         const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
 
-        const { ctx } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx } = await createInitContext(tempDir);
         // ctx stdin has isTTY = undefined (non-TTY)
 
         await handleInit(ctx, undefined, { name: 'my-project', format: 'yaml' }, promptDeps);
@@ -198,13 +184,12 @@ describe('handleInit - interactive mode', () => {
     });
 
     it('should skip both prompts when --name and target path are both given explicitly and TTY', async () => {
-        const inputMock = mock(async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value');
+        const inputMock = mock(
+            async ({ default: d }: { message: string; default?: string }) => d ?? 'prompted-value',
+        );
         const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
 
-        const { ctx, stdin } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdin } = await createInitContext(tempDir);
         (stdin as unknown as { isTTY: boolean }).isTTY = true;
         const customPath = join(tempDir, 'custom-store');
 
@@ -215,16 +200,15 @@ describe('handleInit - interactive mode', () => {
 
     it('should use prompted store name in the output', async () => {
         const promptedName = 'prompted-store-name';
-        const inputMock = mock(async ({ message, default: d }: { message: string; default?: string }) => {
-            if (message.toLowerCase().includes('name')) return promptedName;
-            return d ?? 'default-path';
-        });
+        const inputMock = mock(
+            async ({ message, default: d }: { message: string; default?: string }) => {
+                if (message.toLowerCase().includes('name')) return promptedName;
+                return d ?? 'default-path';
+            },
+        );
         const promptDeps: PromptDeps = { input: inputMock, confirm: mock(async () => true) };
 
-        const { ctx, stdin, stdout } = createMockContext({
-            adapter: createInitAdapter(),
-            cwd: tempDir,
-        });
+        const { ctx, stdin, stdout } = await createInitContext(tempDir);
         (stdin as unknown as { isTTY: boolean }).isTTY = true;
 
         await handleInit(ctx, undefined, { format: 'json' }, promptDeps);

package/src/store/commands/init.ts

@@ -24,14 +24,17 @@
 
 import { Command } from '@commander-js/extra-typings';
 import { resolve } from 'node:path';
+import { stdin, stdout as processStdout } from 'node:process';
 import { resolveStoreName } from '../utils/resolve-store-name.ts';
 import { throwCliError } from '../../errors.ts';
-import { type StoreData } from '@yeseh/cortex-core/store';
+import { type StoreData, initializeStore } from '@yeseh/cortex-core/store';
 import { type CategoryMode, type CortexContext } from '@yeseh/cortex-core';
 import { serializeOutput, type OutputStoreInit, type OutputFormat } from '../../output.ts';
 import { resolveUserPath } from '../../utils/paths.ts';
-import { createCliCommandContext } from '../../context.ts';
+import { createCliConfigContext } from '../../context.ts';
 import { isTTY, defaultPromptDeps, type PromptDeps } from '../../utils/prompts.ts';
+import type { FilesystemConfigAdapter } from '@yeseh/cortex-storage-fs';
+import { FilesystemStorageAdapter } from '@yeseh/cortex-storage-fs';
 
 /**
  * Options for the init command.
@@ -95,7 +98,8 @@ async function promptStoreInitOptions(
     let storePath: string;
     if (explicit.path) {
         storePath = resolved.storePath;
-    } else {
+    }
+    else {
         const promptedPath = await promptDeps.input({
             message: 'Store path:',
             default: resolved.storePath,
@@ -123,7 +127,8 @@ async function resolveStoreNameOrEmpty(
 ): Promise<string> {
     try {
         return await resolveStoreName(cwd, explicitName);
-    } catch (e) {
+    }
+    catch (e) {
         // When running in a TTY, only swallow errors (and fall back to prompting)
         // if no explicit name was provided. If the user passed an explicit --name,
         // re-throw so they see the actual invalid-name error.
@@ -194,11 +199,6 @@ export async function handleInit(
         });
     }
 
-    const clientResult = ctx.cortex.getStore(finalStoreName);
-    if (!clientResult.ok()) {
-        throwCliError(clientResult.error);
-    }
-
     const storeData: StoreData = {
         kind: 'filesystem',
         categoryMode: (options.categoryMode as CategoryMode) ?? 'free',
@@ -209,8 +209,10 @@ export async function handleInit(
         description: options.description,
     };
 
-    const store = clientResult.value;
-    const createResult = await store.initialize(storeData);
+    const adapter = new FilesystemStorageAdapter(ctx.config as FilesystemConfigAdapter, {
+        rootDirectory: finalStorePath,
+    });
+    const createResult = await initializeStore(adapter, finalStoreName, storeData);
     if (!createResult.ok()) {
         throwCliError(createResult.error);
     }
@@ -242,12 +244,26 @@ export const initCommand = new Command('init')
     .option('-c, --category-mode <mode>', 'Category mode (free, strict, flat)', 'free')
     .option('-o, --format <format>', 'Output format (yaml, json, toon)', 'yaml')
     .action(async (path, options) => {
-        const context = await createCliCommandContext();
-        if (!context.ok()) {
-            throwCliError(context.error);
+        const configCtx = await createCliConfigContext();
+        if (!configCtx.ok()) {
+            throwCliError(configCtx.error);
         }
 
-        await handleInit(context.value, path, {
+        const { configAdapter, effectiveCwd } = configCtx.value;
+
+        // Build a minimal context for handleInit. The init command cannot go
+        // through the full CortexContext/adapterFactory because the store is
+        // not yet registered — the adapter factory would throw STORE_NOT_FOUND.
+        // handleInit only needs cwd, stdin, stdout, and config (to construct
+        // its own adapter directly via initializeStore).
+        const ctx = {
+            config: configAdapter,
+            cwd: effectiveCwd,
+            stdin,
+            stdout: processStdout,
+        } as unknown as CortexContext;
+
+        await handleInit(ctx, path, {
             name: options.name,
             description: options.description,
             categoryMode: options.categoryMode as CategoryMode,

package/src/store/commands/prune.ts

@@ -23,6 +23,7 @@ import { Command } from '@commander-js/extra-typings';
 import { throwCliError } from '../../errors.ts';
 import { type CortexContext } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /**
  * Options for the prune command.
@@ -83,13 +84,13 @@ export async function handlePrune(
     ctx: CortexContext,
     storeName: string | undefined,
     options: PruneCommandOptions,
-    deps: PruneHandlerDeps = {},
+    deps: PruneHandlerDeps = {}
 ): Promise<void> {
     const now = deps.now ?? ctx.now();
     const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
 
     // Get store through Cortex client
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }
@@ -121,8 +122,7 @@ export async function handlePrune(
     const paths = pruned.map((entry) => entry.path).join('\n  ');
     if (options.dryRun) {
         stdout.write(`Would prune ${pruned.length} expired memories:\n  ${paths}\n`);
-    }
-    else {
+    } else {
         stdout.write(`Pruned ${pruned.length} expired memories:\n  ${paths}\n`);
     }
 }

package/src/store/commands/reindexs.ts

@@ -18,6 +18,7 @@ import { Command } from '@commander-js/extra-typings';
 import { throwCliError } from '../../errors.ts';
 import { type CortexContext } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /**
  * Dependencies for the reindex command handler.
@@ -45,12 +46,12 @@ export interface ReindexHandlerDeps {
 export async function handleReindex(
     ctx: CortexContext,
     storeName: string | undefined,
-    deps: ReindexHandlerDeps = {},
+    deps: ReindexHandlerDeps = {}
 ): Promise<void> {
     const stdout = deps.stdout ?? ctx.stdout ?? process.stdout;
-    
+
     // Get store through Cortex client
-    const effectiveStoreName = storeName ?? 'global';
+    const effectiveStoreName = resolveDefaultStore(ctx, storeName);
     const storeResult = ctx.cortex.getStore(effectiveStoreName);
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);

package/src/tests/cli.integration.spec.ts

@@ -1167,4 +1167,140 @@ describe('Cortex CLI Integration Tests', () => {
             expect(result.stdout).toContain('reindex');
         });
     });
+
+    describe('store init command', () => {
+        it('should initialize a new store when no store is configured', async () => {
+            // Create an isolated directory with no pre-configured stores — the
+            // config.yaml exists but has no store entries, simulating a fresh install.
+            const freshDir = await fs.mkdtemp(join(tmpdir(), 'cortex-store-init-'));
+            const configDir = join(freshDir, '.config', 'cortex');
+            await fs.mkdir(configDir, { recursive: true });
+            await fs.writeFile(join(configDir, 'config.yaml'), 'stores: {}\n', 'utf8');
+
+            const storePath = join(freshDir, '.cortex', 'memory');
+
+            try {
+                const result = await runCortexCli(
+                    [
+                        'store',
+                        'init',
+                        storePath,
+                        '--name',
+                        'my-project',
+                        '--format',
+                        'json',
+                    ],
+                    {
+                        cwd: freshDir,
+                        env: { CORTEX_CONFIG_DIR: configDir },
+                    },
+                );
+
+                expectCliOk([
+                    'store',
+                    'init',
+                    storePath,
+                    '--name',
+                    'my-project',
+                ], result);
+                expect(result.exitCode).toBe(0);
+
+                const parsed = JSON.parse(result.stdout) as {
+                    value: { name: string; path: string };
+                };
+                expect(parsed.value.name).toBe('my-project');
+                expect(parsed.value.path).toBe(storePath);
+
+                // Verify the store was registered in config.yaml
+                const configContent = await fs.readFile(join(configDir, 'config.yaml'), 'utf8');
+                expect(configContent).toContain('my-project');
+                expect(configContent).toContain(storePath);
+            }
+            finally {
+                await fs.rm(freshDir, { recursive: true, force: true });
+            }
+        });
+
+        it('should create the store directory when it does not yet exist', async () => {
+            const freshDir = await fs.mkdtemp(join(tmpdir(), 'cortex-store-init-newdir-'));
+            const configDir = join(freshDir, '.config', 'cortex');
+            await fs.mkdir(configDir, { recursive: true });
+            await fs.writeFile(join(configDir, 'config.yaml'), 'stores: {}\n', 'utf8');
+
+            // Point at a path that does NOT yet exist on disk
+            const storePath = join(freshDir, 'brand-new-store');
+
+            try {
+                const result = await runCortexCli(
+                    [
+                        'store',
+                        'init',
+                        storePath,
+                        '--name',
+                        'new-dir-store',
+                        '--format',
+                        'json',
+                    ],
+                    {
+                        cwd: freshDir,
+                        env: { CORTEX_CONFIG_DIR: configDir },
+                    },
+                );
+
+                expectCliOk([
+                    'store',
+                    'init',
+                    storePath,
+                    '--name',
+                    'new-dir-store',
+                ], result);
+
+                // The directory must have been created by the init command
+                const dirStat = await fs.stat(storePath);
+                expect(dirStat.isDirectory()).toBe(true);
+            }
+            finally {
+                await fs.rm(freshDir, { recursive: true, force: true });
+            }
+        });
+
+        it('should fail when the store name already exists', async () => {
+            // Register a store first using the existing testProject setup
+            const storePath = join(testProject, '.cortex', 'memory2');
+            const firstInit = await runCortexCli(
+                [
+                    'store',
+                    'init',
+                    storePath,
+                    '--name',
+                    'existing-store',
+                    '--format',
+                    'json',
+                ],
+                { cwd: testProject },
+            );
+            expectCliOk([
+                'store',
+                'init',
+                storePath,
+                '--name',
+                'existing-store',
+            ], firstInit);
+
+            // Attempt to init the same name again — should fail
+            const secondInit = await runCortexCli(
+                [
+                    'store',
+                    'init',
+                    join(testProject, '.cortex', 'memory3'),
+                    '--name',
+                    'existing-store',
+                ],
+                { cwd: testProject },
+            );
+
+            expect(secondInit.exitCode).toBe(1);
+            expect(secondInit.stderr.toLowerCase()).toMatch(/already exists/);
+        });
+    });
 });

package/src/utils/input.ts

@@ -49,7 +49,7 @@ type InputResult = Result<InputContent, InputError>;
 type OptionalContentResult = Result<InputContent | null, InputError>;
 
 export const readContentFromFile = async (
-    filePath: string | undefined
+    filePath: string | undefined,
 ): Promise<OptionalContentResult> => {
     if (filePath === undefined) {
         return ok(null);
@@ -64,7 +64,8 @@ export const readContentFromFile = async (
     try {
         const content = await readFile(trimmed, 'utf8');
         return ok({ content, source: 'file' });
-    } catch (error) {
+    }
+    catch (error) {
         return err({
             code: 'FILE_READ_FAILED',
             message: `Failed to read content file: ${trimmed}.`,
@@ -75,7 +76,7 @@ export const readContentFromFile = async (
 };
 
 export const readContentFromStream = async (
-    stream: NodeJS.ReadableStream
+    stream: NodeJS.ReadableStream,
 ): Promise<OptionalContentResult> => {
     const isTty = 'isTTY' in stream ? Boolean(stream.isTTY) : false;
     if (isTty) {
@@ -110,7 +111,11 @@ export const resolveInput = async (source: InputSource): Promise<InputResult> =>
         source.stream !== undefined &&
         !('isTTY' in source.stream && Boolean((source.stream as { isTTY?: boolean }).isTTY));
 
-    const requestedSources = [contentProvided, fileProvided, streamRequested].filter(Boolean);
+    const requestedSources = [
+        contentProvided,
+        fileProvided,
+        streamRequested,
+    ].filter(Boolean);
 
     if (requestedSources.length > 1) {
         return err({