@yeseh/cortex-cli 0.6.0 → 0.6.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@yeseh/cortex-cli",
-    "version": "0.6.0",
+    "version": "0.6.3",
     "license": "MIT",
     "type": "module",
     "repository": {
@@ -34,8 +34,8 @@
         "typescript": "^5"
     },
     "dependencies": {
-        "@yeseh/cortex-core": "0.6.0",
-        "@yeseh/cortex-storage-fs": "0.6.0",
+        "@yeseh/cortex-core": "workspace:*",
+        "@yeseh/cortex-storage-fs": "workspace:*",
         "@commander-js/extra-typings": "^14.0.0",
         "@inquirer/prompts": "^8.0.0",
         "@toon-format/toon": "^1.0.0",

package/src/category/commands/create.ts

@@ -22,6 +22,7 @@ import { type CortexContext, type Result } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
 import { throwCliError } from '../../errors.ts';
 import { serializeOutput, type OutputFormat } from '../../output.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /** Options parsed by Commander for the create command */
 export interface CreateCommandOptions {
@@ -39,7 +40,7 @@ export interface CreateCommandOptions {
 function writeCreateOutput(
     payload: { path: string; created: boolean },
     options: CreateCommandOptions,
-    stdout: NodeJS.WritableStream,
+    stdout: NodeJS.WritableStream
 ): void {
     const rawFormat = options.format;
 
@@ -49,7 +50,10 @@ function writeCreateOutput(
         return;
     }
 
-    const serialized = serializeOutput({ kind: 'created-category', value: payload }, rawFormat as OutputFormat);
+    const serialized = serializeOutput(
+        { kind: 'created-category', value: payload },
+        rawFormat as OutputFormat
+    );
     if (!serialized.ok()) {
         throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
     }
@@ -85,7 +89,7 @@ export async function handleCreate(
     path: string,
     options: CreateCommandOptions = {}
 ): Promise<void> {
-    const store = unwrapOrThrow(ctx.cortex.getStore(storeName ?? 'global'));
+    const store = unwrapOrThrow(ctx.cortex.getStore(resolveDefaultStore(ctx, storeName)));
     const root = unwrapOrThrow(store.root());
     const category = unwrapOrThrow(root.getCategory(path));
     const result = unwrapOrThrow(await category.create());

package/src/context.ts

@@ -24,7 +24,7 @@ const makeAbsolute = (pathStr: string): string => {
 
 export const validateStorePath = (
     storePath: string,
-    storeName: string,
+    storeName: string
 ): Result<void, ConfigValidationError> => {
     if (!isAbsolute(storePath)) {
         return err({
@@ -65,14 +65,19 @@ export const createCliAdapterFactory = (configAdapter: FilesystemConfigAdapter)
         const stores = configAdapter.stores!;
         const storeEntry = stores[storeName];
         if (!storeEntry) {
+            const available = Object.keys(stores).join(', ') || 'none';
             throw new Error(
-                `Store '${storeName}' not found. Available stores: ${Object.keys(stores).join(', ')}`,
+                `Store '${storeName}' is not registered. Available stores: ${available}. ` +
+                    'Use --store to specify a registered store, or run `cortex store init` to create one.'
             );
         }
 
         const storePath = storeEntry.properties?.path as string | undefined;
         if (!storePath) {
-            throw new Error(`Store '${storeName}' has no path configured in properties.`);
+            throw new Error(
+                `Store '${storeName}' has no path configured. ` +
+                    'Check your cortex config or re-run `cortex store init`.'
+            );
         }
 
         return new FilesystemStorageAdapter(configAdapter, {
@@ -82,10 +87,11 @@ export const createCliAdapterFactory = (configAdapter: FilesystemConfigAdapter)
 };
 
 export const createCliConfigContext = async (
-    options: CliContextOptions = {},
+    options: CliContextOptions = {}
 ): Promise<Result<CliConfigContext, any>> => {
     const envConfigPath = process.env.CORTEX_CONFIG;
     const envConfigDir = process.env.CORTEX_CONFIG_DIR;
+    const envConfigCwd = process.env.CORTEX_CONFIG_CWD;
 
     const explicitConfigPath =
         typeof envConfigPath === 'string' && envConfigPath.length > 0
@@ -93,10 +99,10 @@ export const createCliConfigContext = async (
             : undefined;
 
     const dir = options.configDir ?? envConfigDir ?? resolve(homedir(), '.config', 'cortex');
+
     const absoluteDir = makeAbsolute(dir);
     const configPath = explicitConfigPath ?? resolve(absoluteDir, 'config.yaml');
 
-    const envConfigCwd = process.env.CORTEX_CONFIG_CWD;
     const effectiveCwd =
         options.configCwd ??
         (typeof envConfigCwd === 'string' && envConfigCwd.length > 0
@@ -109,20 +115,10 @@ export const createCliConfigContext = async (
         return initResult;
     }
 
-    const settingsResult = await configAdapter.getSettings();
-    if (!settingsResult.ok()) {
-        return settingsResult;
-    }
-
-    const storesResult = await configAdapter.getStores();
-    if (!storesResult.ok()) {
-        return storesResult;
-    }
-
     return ok({
         configAdapter,
-        settings: settingsResult.value,
-        stores: storesResult.value,
+        settings: configAdapter.settings!,
+        stores: configAdapter.stores!,
         effectiveCwd,
     });
 };
@@ -131,7 +127,7 @@ export const createCliConfigContext = async (
  * This function is used to create a context object that can be injected into command handlers for consistent access to the Cortex client and other utilities.
  */
 export const createCliCommandContext = async (
-    configDir?: string,
+    configDir?: string
 ): Promise<Result<CortexContext, any>> => {
     try {
         const configContextResult = await createCliConfigContext({
@@ -165,8 +161,7 @@ export const createCliCommandContext = async (
         };
 
         return ok(context);
-    }
-    catch (error) {
+    } catch (error) {
         return err({
             code: 'CONTEXT_CREATION_FAILED',
             message: `Unexpected error creating CLI command context: ${error instanceof Error ? error.message : String(error)}`,

package/src/memory/commands/add.ts

@@ -28,6 +28,7 @@ import { resolveInput as resolveCliContent } from '../../utils/input.ts';
 import { parseExpiresAt, parseTags } from '../parsing.ts';
 import { createCliCommandContext } from '../../context.ts';
 import { serializeOutput, type OutputFormat } from '../../output.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /** Options parsed by Commander for the add command */
 export interface AddCommandOptions {
@@ -77,7 +78,7 @@ export async function handleAdd(
     const expiresAt = parseExpiresAt(options.expiresAt);
     const citations = options.citations ?? [];
 
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }

package/src/memory/commands/list.ts

@@ -36,6 +36,7 @@ import { serialize, type CortexContext } from '@yeseh/cortex-core';
 import type { SubcategoryEntry } from '@yeseh/cortex-core/category';
 import { type OutputFormat } from '../../output.ts';
 import { createCliCommandContext } from '../../context.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /**
  * Options for the list command.
@@ -116,7 +117,7 @@ export async function handleList(
         throwCliError(categoryResult.error);
     }
 
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }

package/src/memory/commands/move.ts

@@ -17,6 +17,7 @@ import { throwCliError } from '../../errors.ts';
 import { MemoryPath, type CortexContext } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
 import { serializeOutput, type OutputFormat } from '../../output.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /** Options for the move command. */
 export interface MoveCommandOptions {
@@ -50,7 +51,7 @@ export async function handleMove(
         throwCliError(toResult.error);
     }
 
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }
@@ -81,7 +82,10 @@ export async function handleMove(
     } else {
         const format = rawFormat as OutputFormat;
         const serialized = serializeOutput(
-            { kind: 'moved-memory', value: { from: fromResult.value.toString(), to: toResult.value.toString() } },
+            {
+                kind: 'moved-memory',
+                value: { from: fromResult.value.toString(), to: toResult.value.toString() },
+            },
             format
         );
         if (!serialized.ok()) {

package/src/memory/commands/remove.ts

@@ -18,6 +18,7 @@ import { throwCliError } from '../../errors.ts';
 import { MemoryPath, type CortexContext } from '@yeseh/cortex-core';
 import { createCliCommandContext } from '../../context.ts';
 import { serializeOutput, type OutputFormat } from '../../output.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /** Options for the remove command. */
 export interface RemoveCommandOptions {
@@ -44,7 +45,7 @@ export async function handleRemove(
         throwCliError(pathResult.error);
     }
 
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }
@@ -74,7 +75,10 @@ export async function handleRemove(
         out.write(`Removed memory ${pathResult.value.toString()}.\n`);
     } else {
         const format = rawFormat as OutputFormat;
-        const serialized = serializeOutput({kind: 'path', value: { path: pathResult.value.toString() }}, format);
+        const serialized = serializeOutput(
+            { kind: 'path', value: { path: pathResult.value.toString() } },
+            format
+        );
         if (!serialized.ok()) {
             throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
         }

package/src/memory/commands/show.ts

@@ -28,6 +28,7 @@ import { defaultTokenizer, MemoryPath, type CortexContext } from '@yeseh/cortex-
 import { type StoreClient } from '@yeseh/cortex-core/store';
 import { serializeOutput, type OutputMemory, type OutputFormat } from '../../output.ts';
 import { createCliCommandContext } from '../../context.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /**
  * Options for the show command.
@@ -80,7 +81,7 @@ export async function handleShow(
         throwCliError(pathResult.error);
     }
 
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }
@@ -126,7 +127,7 @@ export async function handleShow(
     };
 
     const format = (options.format as OutputFormat) ?? 'yaml';
-    const serialized = serializeOutput({kind: 'memory', value: outputMemory}, format);
+    const serialized = serializeOutput({ kind: 'memory', value: outputMemory }, format);
     if (!serialized.ok()) {
         throwCliError({ code: 'SERIALIZE_FAILED', message: serialized.error.message });
     }

package/src/memory/commands/update.ts

@@ -33,6 +33,7 @@ import { resolveInput as resolveCliContent } from '../../utils/input.ts';
 import { parseExpiresAt, parseTags } from '../parsing.ts';
 import { createCliCommandContext } from '../../context.ts';
 import { serializeOutput, type OutputFormat } from '../../output.ts';
+import { resolveDefaultStore } from '../../utils/resolve-default-store.ts';
 
 /** Options parsed by Commander for the update command */
 export interface UpdateCommandOptions {
@@ -148,7 +149,7 @@ export async function handleUpdate(
     const expiresAt = parseUpdateExpiresAt(options.expiresAt);
     const updates = buildUpdates(content, tags, expiresAt, options.citation);
 
-    const storeResult = ctx.cortex.getStore(storeName ?? 'global');
+    const storeResult = ctx.cortex.getStore(resolveDefaultStore(ctx, storeName));
     if (!storeResult.ok()) {
         throwCliError(storeResult.error);
     }

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,