@gmickel/gno 1.24.0 → 1.26.0

package/src/cli/commands/context/add.ts

@@ -6,7 +6,9 @@
  * @module src/cli/commands/context/add
  */
 
-import { loadConfig, parseScope, saveConfig } from "../../../config";
+import { parseScope } from "../../../config";
+import { applyConfigFileChange } from "../../../core/config-mutation";
+import { normalizePersistedContextText } from "../../../core/context-identity";
 
 /**
  * Exit codes
@@ -21,7 +23,11 @@ const EXIT_VALIDATION = 1;
  * @param text - Context description text
  * @returns Exit code
  */
-export async function contextAdd(scope: string, text: string): Promise<number> {
+export async function contextAdd(
+  scope: string,
+  text: string,
+  options: { configPath?: string } = {}
+): Promise<number> {
   // Parse scope
   const parsed = parseScope(scope);
   if (!parsed) {
@@ -32,33 +38,38 @@ export async function contextAdd(scope: string, text: string): Promise<number> {
     return EXIT_VALIDATION;
   }
 
-  // Load config
-  const configResult = await loadConfig();
-  if (!configResult.ok) {
-    console.error(`Error: ${configResult.error.message}`);
+  const normalizedText = normalizePersistedContextText(text);
+  if (!normalizedText) {
+    console.error("Error: Context text must not be empty");
     return EXIT_VALIDATION;
   }
 
-  const config = configResult.value;
-
-  // Check for duplicate scope
-  const existing = config.contexts.find((ctx) => ctx.scopeKey === parsed.key);
-  if (existing) {
-    console.error(`Error: Context for scope "${scope}" already exists`);
-    return EXIT_VALIDATION;
-  }
-
-  // Add context
-  config.contexts.push({
-    scopeType: parsed.type,
-    scopeKey: parsed.key,
-    text,
-  });
-
-  // Save config
-  const saveResult = await saveConfig(config);
-  if (!saveResult.ok) {
-    console.error(`Error: ${saveResult.error.message}`);
+  const mutation = await applyConfigFileChange(
+    { configPath: options.configPath },
+    (config) => {
+      const duplicate = config.contexts.some(
+        (context) =>
+          context.scopeType === parsed.type &&
+          context.scopeKey === parsed.key &&
+          normalizePersistedContextText(context.text) === normalizedText
+      );
+      if (duplicate) {
+        return {
+          ok: false as const,
+          error: `Context for scope "${scope}" with that text already exists`,
+          code: "DUPLICATE",
+        };
+      }
+      config.contexts.push({
+        scopeType: parsed.type,
+        scopeKey: parsed.key,
+        text: normalizedText,
+      });
+      return { ok: true as const, config };
+    }
+  );
+  if (!mutation.ok) {
+    console.error(`Error: ${mutation.error}`);
     return EXIT_VALIDATION;
   }
 

package/src/cli/commands/context/rm.ts

@@ -6,7 +6,9 @@
  * @module src/cli/commands/context/rm
  */
 
-import { loadConfig, saveConfig } from "../../../config";
+import { parseScope } from "../../../config";
+import { applyConfigFileChange } from "../../../core/config-mutation";
+import { normalizePersistedContextText } from "../../../core/context-identity";
 
 /**
  * Exit codes
@@ -20,30 +22,55 @@ const EXIT_VALIDATION = 1;
  * @param scope - Scope key to remove
  * @returns Exit code
  */
-export async function contextRm(scope: string): Promise<number> {
-  // Load config
-  const configResult = await loadConfig();
-  if (!configResult.ok) {
-    console.error(`Error: ${configResult.error.message}`);
+export async function contextRm(
+  scope: string,
+  text?: string,
+  options: { configPath?: string } = {}
+): Promise<number> {
+  const parsed = parseScope(scope);
+  if (!parsed) {
+    console.error(`Error: Invalid scope format: ${scope}`);
     return EXIT_VALIDATION;
   }
-
-  const config = configResult.value;
-
-  // Find context
-  const index = config.contexts.findIndex((ctx) => ctx.scopeKey === scope);
-  if (index === -1) {
-    console.error(`Error: Context for scope "${scope}" not found`);
+  const normalizedText =
+    text === undefined ? undefined : normalizePersistedContextText(text);
+  if (normalizedText === "") {
+    console.error("Error: Context text must not be empty");
     return EXIT_VALIDATION;
   }
 
-  // Remove context
-  config.contexts.splice(index, 1);
-
-  // Save config
-  const saveResult = await saveConfig(config);
-  if (!saveResult.ok) {
-    console.error(`Error: ${saveResult.error.message}`);
+  const mutation = await applyConfigFileChange(
+    { configPath: options.configPath },
+    (config) => {
+      const matches = config.contexts
+        .map((context, index) => ({ context, index }))
+        .filter(
+          ({ context }) =>
+            context.scopeType === parsed.type &&
+            context.scopeKey === parsed.key &&
+            (normalizedText === undefined ||
+              normalizePersistedContextText(context.text) === normalizedText)
+        );
+      if (matches.length === 0) {
+        return {
+          ok: false as const,
+          error: `Context for scope "${scope}" not found`,
+          code: "NOT_FOUND",
+        };
+      }
+      if (normalizedText === undefined && matches.length > 1) {
+        return {
+          ok: false as const,
+          error: `Multiple contexts exist for scope "${scope}"; pass the exact text to remove`,
+          code: "AMBIGUOUS",
+        };
+      }
+      config.contexts.splice(matches[0]!.index, 1);
+      return { ok: true as const, config };
+    }
+  );
+  if (!mutation.ok) {
+    console.error(`Error: ${mutation.error}`);
     return EXIT_VALIDATION;
   }
 

package/src/cli/commands/init.ts

@@ -17,13 +17,12 @@ import {
   FTS_TOKENIZERS,
   type FtsTokenizer,
   getConfigPaths,
-  isInitialized,
   isValidLanguageHint,
-  loadConfigOrNull,
   pathExists,
-  saveConfig,
   toAbsolutePath,
 } from "../../config";
+import { applyConfigFileChange } from "../../core/config-mutation";
+import { SqliteAdapter } from "../../store/sqlite/adapter";
 
 /** Pattern to replace invalid chars in collection names with hyphens */
 const INVALID_NAME_CHARS = /[^a-z0-9_-]/g;
@@ -70,166 +69,97 @@ export interface InitResult {
   error?: string;
 }
 
-/**
- * Handle case when already initialized.
- */
-async function handleAlreadyInitialized(
-  options: InitOptions,
-  paths: ReturnType<typeof getConfigPaths>
-): Promise<InitResult> {
-  // Ensure directories exist (may have been deleted by reset)
-  await ensureDirectories();
-
-  const config = await loadConfigOrNull(options.configPath);
-  const dbPath = getIndexDbPath();
-
-  if (!options.path) {
-    return {
-      success: true,
-      alreadyInitialized: true,
-      configPath: paths.configFile,
-      dataDir: paths.dataDir,
-      dbPath,
-    };
-  }
-
-  if (!config) {
-    return {
-      success: false,
-      configPath: paths.configFile,
-      dataDir: paths.dataDir,
-      dbPath,
-      error: "Config exists but could not be loaded",
-    };
-  }
-
-  const collectionResult = await addCollectionToConfig(config, options);
-  if (!collectionResult.success) {
-    return {
-      success: false,
-      configPath: paths.configFile,
-      dataDir: paths.dataDir,
-      dbPath,
-      error: collectionResult.error,
-    };
-  }
-
-  const saveResult = await saveConfig(config, options.configPath);
-  if (!saveResult.ok) {
-    return {
-      success: false,
-      configPath: paths.configFile,
-      dataDir: paths.dataDir,
-      dbPath,
-      error: saveResult.error.message,
-    };
-  }
-
-  return {
-    success: true,
-    alreadyInitialized: true,
-    configPath: paths.configFile,
-    dataDir: paths.dataDir,
-    dbPath,
-    collectionAdded: collectionResult.collectionName,
-  };
-}
-
 /**
  * Execute gno init command.
  */
 export async function init(options: InitOptions = {}): Promise<InitResult> {
   const paths = getConfigPaths();
+  const configPath = toAbsolutePath(options.configPath ?? paths.configFile);
+  const dbPath = getIndexDbPath();
 
-  // Check if already initialized
-  const initialized = await isInitialized(options.configPath);
-  if (initialized) {
-    return handleAlreadyInitialized(options, paths);
-  }
-
-  // Create directories
   const dirResult = await ensureDirectories();
   if (!dirResult.ok) {
     return {
       success: false,
-      configPath: paths.configFile,
+      configPath,
       dataDir: paths.dataDir,
-      dbPath: getIndexDbPath(),
+      dbPath,
       error: dirResult.error.message,
     };
   }
 
-  // Validate tokenizer option if provided
   if (options.tokenizer && !FTS_TOKENIZERS.includes(options.tokenizer)) {
     return {
       success: false,
-      configPath: paths.configFile,
+      configPath,
       dataDir: paths.dataDir,
-      dbPath: getIndexDbPath(),
+      dbPath,
       error: `Invalid tokenizer: ${options.tokenizer}. Valid: ${FTS_TOKENIZERS.join(", ")}`,
     };
   }
 
-  // Create default config
-  const config = createDefaultConfig();
-
-  // Set tokenizer if provided
-  if (options.tokenizer) {
-    config.ftsTokenizer = options.tokenizer;
-  }
-
-  // Add collection if path provided
-  let collectionName: string | undefined;
-  if (options.path) {
-    const collectionResult = await addCollectionToConfig(config, options);
-    if (!collectionResult.success) {
+  const mutation = await applyConfigFileChange(
+    {
+      configPath,
+      createConfigIfMissing: createDefaultConfig,
+    },
+    async (config, state) => {
+      if (state.created && options.tokenizer) {
+        config.ftsTokenizer = options.tokenizer;
+      }
+      let collectionName: string | undefined;
+      if (options.path) {
+        const collectionResult = await addCollectionToConfig(config, options);
+        if (!collectionResult.success) {
+          return {
+            ok: false as const,
+            error: collectionResult.error,
+            code: "VALIDATION",
+          };
+        }
+        collectionName = collectionResult.collectionName;
+      }
       return {
-        success: false,
-        configPath: paths.configFile,
-        dataDir: paths.dataDir,
-        dbPath: getIndexDbPath(),
-        error: collectionResult.error,
+        ok: true as const,
+        config,
+        skipSave: !state.created && !options.path,
+        value: {
+          alreadyInitialized: !state.created,
+          collectionName,
+        },
       };
     }
-    collectionName = collectionResult.collectionName;
-  }
-
-  // Save config
-  const saveResult = await saveConfig(config, options.configPath);
-  if (!saveResult.ok) {
+  );
+  if (!mutation.ok) {
     return {
       success: false,
-      configPath: paths.configFile,
+      configPath,
       dataDir: paths.dataDir,
-      dbPath: getIndexDbPath(),
-      error: saveResult.error.message,
+      dbPath,
+      error: mutation.error,
     };
   }
 
-  // Create DB placeholder file only if it doesn't exist (don't truncate existing DB)
-  const dbPath = getIndexDbPath();
-  const dbFile = Bun.file(dbPath);
-  const dbExists = await dbFile.exists();
-  if (!dbExists) {
-    try {
-      await Bun.write(dbPath, "");
-    } catch (error) {
-      return {
-        success: false,
-        configPath: paths.configFile,
-        dataDir: paths.dataDir,
-        dbPath,
-        error: `Failed to create database file: ${error instanceof Error ? error.message : String(error)}`,
-      };
-    }
+  const store = new SqliteAdapter();
+  const opened = await store.open(dbPath, mutation.config.ftsTokenizer);
+  if (!opened.ok) {
+    return {
+      success: false,
+      configPath,
+      dataDir: paths.dataDir,
+      dbPath,
+      error: `Failed to initialize database: ${opened.error.message}`,
+    };
   }
+  await store.close();
 
   return {
     success: true,
-    configPath: paths.configFile,
+    alreadyInitialized: mutation.value?.alreadyInitialized || undefined,
+    configPath,
     dataDir: paths.dataDir,
     dbPath,
-    collectionAdded: collectionName,
+    collectionAdded: mutation.value?.collectionName,
   };
 }
 

package/src/cli/commands/models/use.ts

@@ -5,8 +5,8 @@
  * @module src/cli/commands/models/use
  */
 
-import { createDefaultConfig, loadConfig } from "../../../config";
-import { saveConfig } from "../../../config/saver";
+import { createDefaultConfig } from "../../../config";
+import { applyConfigFileChange } from "../../../core/config-mutation";
 import { getPreset, listPresets, resolveModelUri } from "../../../llm/registry";
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -38,51 +38,56 @@ export async function modelsUse(
   presetId: string,
   options: ModelsUseOptions = {}
 ): Promise<ModelsUseResult> {
-  // Load existing config or create default
-  const configResult = await loadConfig(options.configPath);
-  const config = configResult.ok ? configResult.value : createDefaultConfig();
-  const previousEmbedModel = resolveModelUri(config, "embed");
-
-  // Check if preset exists
-  const preset = getPreset(config, presetId);
-  if (!preset) {
-    const available = listPresets(config)
-      .map((p) => p.id)
-      .join(", ");
-    return {
-      success: false,
-      error: `Unknown preset: ${presetId}. Available: ${available}`,
-    };
-  }
-
-  // Update config with new active preset
-  const updatedConfig = {
-    ...config,
-    models: {
-      activePreset: presetId,
-      // Preserve existing presets or use defaults from code
-      presets: config.models?.presets ?? [],
-      loadTimeout: config.models?.loadTimeout ?? 60_000,
-      inferenceTimeout: config.models?.inferenceTimeout ?? 30_000,
-      expandContextSize: config.models?.expandContextSize ?? 2_048,
-      warmModelTtl: config.models?.warmModelTtl ?? 300_000,
+  const mutation = await applyConfigFileChange(
+    {
+      configPath: options.configPath,
+      createConfigIfMissing: createDefaultConfig,
     },
-  };
-
-  // Save updated config
-  const saveResult = await saveConfig(updatedConfig, options.configPath);
-  if (!saveResult.ok) {
+    (config) => {
+      const preset = getPreset(config, presetId);
+      if (!preset) {
+        const available = listPresets(config)
+          .map((item) => item.id)
+          .join(", ");
+        return {
+          ok: false as const,
+          error: `Unknown preset: ${presetId}. Available: ${available}`,
+          code: "UNKNOWN_PRESET",
+        };
+      }
+      const previousEmbedModel = resolveModelUri(config, "embed");
+      return {
+        ok: true as const,
+        config: {
+          ...config,
+          models: {
+            activePreset: presetId,
+            presets: config.models?.presets ?? [],
+            loadTimeout: config.models?.loadTimeout ?? 60_000,
+            inferenceTimeout: config.models?.inferenceTimeout ?? 30_000,
+            expandContextSize: config.models?.expandContextSize ?? 2_048,
+            warmModelTtl: config.models?.warmModelTtl ?? 300_000,
+          },
+        },
+        value: {
+          name: preset.name,
+          embedModelChanged: previousEmbedModel !== preset.embed,
+        },
+      };
+    }
+  );
+  if (!mutation.ok) {
     return {
       success: false,
-      error: `Failed to save config: ${saveResult.error.message}`,
+      error: mutation.error,
     };
   }
 
   return {
     success: true,
     preset: presetId,
-    name: preset.name,
-    embedModelChanged: previousEmbedModel !== preset.embed,
+    name: mutation.value!.name,
+    embedModelChanged: mutation.value!.embedModelChanged,
   };
 }