@gmickel/gno 1.25.1 → 1.26.0

package/src/cli/commands/collection/remove.ts

@@ -3,43 +3,43 @@
  */
 
 import { removeCollection } from "../../../collection";
-import { loadConfig, saveConfig } from "../../../config";
+import { applyConfigFileChange } from "../../../core/config-mutation";
 import { CliError } from "../../errors";
 
-export async function collectionRemove(name: string): Promise<void> {
-  // Load config
-  const configResult = await loadConfig();
-  if (!configResult.ok) {
-    throw new CliError(
-      "RUNTIME",
-      `Failed to load config: ${configResult.error.message}`
-    );
-  }
-
-  // Remove collection using shared module
-  const result = removeCollection(configResult.value, { name });
+export async function collectionRemove(
+  name: string,
+  options: { configPath?: string } = {}
+): Promise<void> {
+  const mutation = await applyConfigFileChange(
+    { configPath: options.configPath },
+    (config) => {
+      const result = removeCollection(config, { name });
+      return result.ok
+        ? {
+            ok: true as const,
+            config: result.config,
+            value: result.collection,
+          }
+        : {
+            ok: false as const,
+            error: result.message,
+            code: result.code,
+          };
+    }
+  );
 
-  if (!result.ok) {
+  if (!mutation.ok) {
     // Map collection error codes to CLI error codes
     const cliCode =
-      result.code === "VALIDATION" ||
-      result.code === "NOT_FOUND" ||
-      result.code === "HAS_REFERENCES"
+      mutation.code === "VALIDATION" ||
+      mutation.code === "NOT_FOUND" ||
+      mutation.code === "HAS_REFERENCES"
         ? "VALIDATION"
         : "RUNTIME";
-    throw new CliError(cliCode, result.message);
-  }
-
-  // Save config
-  const saveResult = await saveConfig(result.config);
-  if (!saveResult.ok) {
-    throw new CliError(
-      "RUNTIME",
-      `Failed to save config: ${saveResult.error.message}`
-    );
+    throw new CliError(cliCode, mutation.error);
   }
 
   process.stdout.write(
-    `Collection "${result.collection.name}" removed successfully\n`
+    `Collection "${mutation.value?.name}" removed successfully\n`
   );
 }

package/src/cli/commands/collection/rename.ts

@@ -2,90 +2,72 @@
  * gno collection rename - Rename a collection
  */
 
-import {
-  CollectionSchema,
-  getCollectionFromScope,
-  loadConfig,
-  saveConfig,
-} from "../../../config";
+import { CollectionSchema, getCollectionFromScope } from "../../../config";
+import { applyConfigFileChange } from "../../../core/config-mutation";
 import { CliError } from "../../errors";
 
 export async function collectionRename(
   oldName: string,
-  newName: string
+  newName: string,
+  options: { configPath?: string } = {}
 ): Promise<void> {
   const oldCollectionName = oldName.toLowerCase();
   const newCollectionName = newName.toLowerCase();
 
-  // Load config
-  const result = await loadConfig();
-  if (!result.ok) {
-    throw new CliError(
-      "RUNTIME",
-      `Failed to load config: ${result.error.message}`
-    );
-  }
-
-  const config = result.value;
-
-  // Find old collection
-  const collection = config.collections.find(
-    (c) => c.name === oldCollectionName
-  );
-  if (!collection) {
-    throw new CliError(
-      "VALIDATION",
-      `Collection "${oldCollectionName}" not found`
-    );
-  }
-
-  // Check if new name already exists
-  const existingNew = config.collections.find(
-    (c) => c.name === newCollectionName
-  );
-  if (existingNew) {
-    throw new CliError(
-      "VALIDATION",
-      `Collection "${newCollectionName}" already exists`
-    );
-  }
-
-  // Validate new name
-  const testCollection = { ...collection, name: newCollectionName };
-  const validation = CollectionSchema.safeParse(testCollection);
-  if (!validation.success) {
-    throw new CliError(
-      "VALIDATION",
-      `Invalid collection name: ${validation.error.issues[0]?.message ?? "unknown error"}`
-    );
-  }
-
-  // Rename collection
-  collection.name = newCollectionName;
-
-  // Update contexts that reference this collection
-  for (const context of config.contexts) {
-    const collFromScope = getCollectionFromScope(context.scopeKey);
-    if (collFromScope === oldCollectionName) {
-      // Update scope key
-      if (context.scopeType === "collection") {
-        context.scopeKey = `${newCollectionName}:`;
-      } else if (context.scopeType === "prefix") {
-        // Replace collection name in URI
-        context.scopeKey = context.scopeKey.replace(
-          `gno://${oldCollectionName}/`,
-          `gno://${newCollectionName}/`
-        );
+  const mutation = await applyConfigFileChange(
+    { configPath: options.configPath },
+    (config) => {
+      const collection = config.collections.find(
+        (item) => item.name === oldCollectionName
+      );
+      if (!collection) {
+        return {
+          ok: false as const,
+          error: `Collection "${oldCollectionName}" not found`,
+          code: "NOT_FOUND",
+        };
       }
+      if (config.collections.some((item) => item.name === newCollectionName)) {
+        return {
+          ok: false as const,
+          error: `Collection "${newCollectionName}" already exists`,
+          code: "DUPLICATE",
+        };
+      }
+      const validation = CollectionSchema.safeParse({
+        ...collection,
+        name: newCollectionName,
+      });
+      if (!validation.success) {
+        return {
+          ok: false as const,
+          error: `Invalid collection name: ${validation.error.issues[0]?.message ?? "unknown error"}`,
+          code: "VALIDATION",
+        };
+      }
+      collection.name = newCollectionName;
+      for (const context of config.contexts) {
+        if (getCollectionFromScope(context.scopeKey) !== oldCollectionName) {
+          continue;
+        }
+        if (context.scopeType === "collection") {
+          context.scopeKey = `${newCollectionName}:`;
+        } else if (context.scopeType === "prefix") {
+          context.scopeKey = context.scopeKey.replace(
+            `gno://${oldCollectionName}/`,
+            `gno://${newCollectionName}/`
+          );
+        }
+      }
+      return { ok: true as const, config };
     }
-  }
-
-  // Save config
-  const saveResult = await saveConfig(config);
-  if (!saveResult.ok) {
+  );
+  if (!mutation.ok) {
     throw new CliError(
-      "RUNTIME",
-      `Failed to save config: ${saveResult.error.message}`
+      ["NOT_FOUND", "DUPLICATE", "VALIDATION"].includes(mutation.code)
+        ? "VALIDATION"
+        : "RUNTIME",
+      mutation.error
     );
   }
 

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,
   };
 }