@gmickel/gno 0.6.1 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gmickel/gno",
-  "version": "0.6.1",
+  "version": "0.7.0",
   "description": "Local semantic search for your documents. Index Markdown, PDF, and Office files with hybrid BM25 + vector search.",
   "keywords": [
     "search",
@@ -33,7 +33,7 @@
     "vendor"
   ],
   "engines": {
-    "bun": ">=1.0.0"
+    "bun": ">=1.3.0"
   },
   "publishConfig": {
     "access": "public"
@@ -113,11 +113,11 @@
     "evalite": "^1.0.0-beta.15",
     "exceljs": "^4.4.0",
     "lefthook": "^2.0.13",
-    "oxlint-tsgolint": "^0.10.0",
+    "oxlint-tsgolint": "^0.10.1",
     "pdf-lib": "^1.17.1",
     "pptxgenjs": "^4.0.1",
     "tailwindcss": "^4.1.18",
-    "ultracite": "6.5.0"
+    "ultracite": "7.0.4"
   },
   "peerDependencies": {
     "typescript": "^5"

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

@@ -2,11 +2,8 @@
  * gno collection add - Add a new collection
  */
 
+import { addCollection } from '../../../collection';
 import {
-  type Collection,
-  CollectionSchema,
-  DEFAULT_EXCLUDES,
-  DEFAULT_PATTERN,
   loadConfig,
   pathExists,
   saveConfig,
@@ -31,83 +28,45 @@ export async function collectionAdd(
     throw new CliError('VALIDATION', '--name is required');
   }
 
-  const collectionName = options.name.toLowerCase();
-
-  // Expand and validate path
+  // Validate path exists BEFORE loading config (user-friendly error ordering)
   const absolutePath = toAbsolutePath(path);
-
-  // Check if path exists
   const exists = await pathExists(absolutePath);
   if (!exists) {
     throw new CliError('VALIDATION', `Path does not exist: ${absolutePath}`);
   }
 
   // Load config
-  const result = await loadConfig();
-  if (!result.ok) {
+  const configResult = await loadConfig();
+  if (!configResult.ok) {
     throw new CliError(
       'RUNTIME',
-      `Failed to load config: ${result.error.message}`
+      `Failed to load config: ${configResult.error.message}`
     );
   }
 
-  const config = result.value;
-
-  // Check for duplicate name
-  const existing = config.collections.find((c) => c.name === collectionName);
-  if (existing) {
-    throw new CliError(
-      'VALIDATION',
-      `Collection "${collectionName}" already exists`
-    );
-  }
-
-  // Parse options - filter empty, dedupe
-  const includeList = options.include
-    ? [
-        ...new Set(
-          options.include
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean)
-        ),
-      ]
-    : [];
-  const excludeList = options.exclude
-    ? [
-        ...new Set(
-          options.exclude
-            .split(',')
-            .map((s) => s.trim())
-            .filter(Boolean)
-        ),
-      ]
-    : [...DEFAULT_EXCLUDES];
-
-  // Build collection
-  const collection: Collection = {
-    name: collectionName,
-    path: absolutePath,
-    pattern: options.pattern ?? DEFAULT_PATTERN,
-    include: includeList,
-    exclude: excludeList,
+  // Add collection using shared module
+  const result = await addCollection(configResult.value, {
+    path,
+    name: options.name,
+    pattern: options.pattern,
+    include: options.include,
+    exclude: options.exclude,
     updateCmd: options.update,
-  };
+  });
 
-  // Validate collection
-  const validation = CollectionSchema.safeParse(collection);
-  if (!validation.success) {
-    throw new CliError(
-      'VALIDATION',
-      `Invalid collection: ${validation.error.issues[0]?.message ?? 'unknown error'}`
-    );
+  if (!result.ok) {
+    // Map collection error codes to CLI error codes
+    const cliCode =
+      result.code === 'VALIDATION' ||
+      result.code === 'PATH_NOT_FOUND' ||
+      result.code === 'DUPLICATE'
+        ? 'VALIDATION'
+        : 'RUNTIME';
+    throw new CliError(cliCode, result.message);
   }
 
-  // Add to config
-  config.collections.push(validation.data);
-
   // Save config
-  const saveResult = await saveConfig(config);
+  const saveResult = await saveConfig(result.config);
   if (!saveResult.ok) {
     throw new CliError(
       'RUNTIME',
@@ -115,6 +74,8 @@ export async function collectionAdd(
     );
   }
 
-  process.stdout.write(`Collection "${collectionName}" added successfully\n`);
-  process.stdout.write(`Path: ${absolutePath}\n`);
+  process.stdout.write(
+    `Collection "${result.collection.name}" added successfully\n`
+  );
+  process.stdout.write(`Path: ${result.collection.path}\n`);
 }

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

@@ -2,57 +2,36 @@
  * gno collection remove - Remove a collection
  */
 
-import {
-  getCollectionFromScope,
-  loadConfig,
-  saveConfig,
-} from '../../../config';
+import { removeCollection } from '../../../collection';
+import { loadConfig, saveConfig } from '../../../config';
 import { CliError } from '../../errors';
 
 export async function collectionRemove(name: string): Promise<void> {
-  const collectionName = name.toLowerCase();
-
   // Load config
-  const result = await loadConfig();
-  if (!result.ok) {
+  const configResult = await loadConfig();
+  if (!configResult.ok) {
     throw new CliError(
       'RUNTIME',
-      `Failed to load config: ${result.error.message}`
+      `Failed to load config: ${configResult.error.message}`
     );
   }
 
-  const config = result.value;
-
-  // Find collection
-  const collectionIndex = config.collections.findIndex(
-    (c) => c.name === collectionName
-  );
-  if (collectionIndex === -1) {
-    throw new CliError(
-      'VALIDATION',
-      `Collection "${collectionName}" not found`
-    );
-  }
+  // Remove collection using shared module
+  const result = removeCollection(configResult.value, { name });
 
-  // Check if any contexts reference this collection
-  const referencingContexts = config.contexts.filter((ctx) => {
-    const collFromScope = getCollectionFromScope(ctx.scopeKey);
-    return collFromScope === collectionName;
-  });
-
-  if (referencingContexts.length > 0) {
-    const scopes = referencingContexts.map((ctx) => ctx.scopeKey).join(', ');
-    throw new CliError(
-      'VALIDATION',
-      `Collection "${collectionName}" is referenced by contexts: ${scopes}. Remove the contexts first or rename the collection.`
-    );
+  if (!result.ok) {
+    // Map collection error codes to CLI error codes
+    const cliCode =
+      result.code === 'VALIDATION' ||
+      result.code === 'NOT_FOUND' ||
+      result.code === 'HAS_REFERENCES'
+        ? 'VALIDATION'
+        : 'RUNTIME';
+    throw new CliError(cliCode, result.message);
   }
 
-  // Remove collection
-  config.collections.splice(collectionIndex, 1);
-
   // Save config
-  const saveResult = await saveConfig(config);
+  const saveResult = await saveConfig(result.config);
   if (!saveResult.ok) {
     throw new CliError(
       'RUNTIME',
@@ -60,5 +39,7 @@ export async function collectionRemove(name: string): Promise<void> {
     );
   }
 
-  process.stdout.write(`Collection "${collectionName}" removed successfully\n`);
+  process.stdout.write(
+    `Collection "${result.collection.name}" removed successfully\n`
+  );
 }

package/src/cli/commands/embed.ts

@@ -7,7 +7,12 @@
 
 import type { Database } from 'bun:sqlite';
 import { getIndexDbPath } from '../../app/constants';
-import { getConfigPaths, isInitialized, loadConfig } from '../../config';
+import {
+  type Config,
+  getConfigPaths,
+  isInitialized,
+  loadConfig,
+} from '../../config';
 import { LlmAdapter } from '../../llm/nodeLlamaCpp/adapter';
 import { resolveDownloadPolicy } from '../../llm/policy';
 import { getActivePreset } from '../../llm/registry';
@@ -197,35 +202,36 @@ async function processBatches(ctx: BatchContext): Promise<BatchResult> {
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
-// Main Command
+// Helpers
 // ─────────────────────────────────────────────────────────────────────────────
 
+interface EmbedContext {
+  config: Config;
+  modelUri: string;
+  store: SqliteAdapter;
+}
+
 /**
- * Execute gno embed command.
+ * Initialize embed context: check init, load config, open store.
  */
-export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
-  const batchSize = options.batchSize ?? 32;
-  const force = options.force ?? false;
-  const dryRun = options.dryRun ?? false;
-
-  // Check initialization
-  const initialized = await isInitialized(options.configPath);
+async function initEmbedContext(
+  configPath?: string,
+  model?: string
+): Promise<({ ok: true } & EmbedContext) | { ok: false; error: string }> {
+  const initialized = await isInitialized(configPath);
   if (!initialized) {
-    return { success: false, error: 'GNO not initialized. Run: gno init' };
+    return { ok: false, error: 'GNO not initialized. Run: gno init' };
   }
 
-  // Load config
-  const configResult = await loadConfig(options.configPath);
+  const configResult = await loadConfig(configPath);
   if (!configResult.ok) {
-    return { success: false, error: configResult.error.message };
+    return { ok: false, error: configResult.error.message };
   }
   const config = configResult.value;
 
-  // Get model URI
   const preset = getActivePreset(config);
-  const modelUri = options.model ?? preset.embed;
+  const modelUri = model ?? preset.embed;
 
-  // Open store
   const store = new SqliteAdapter();
   const dbPath = getIndexDbPath();
   const paths = getConfigPaths();
@@ -233,8 +239,30 @@ export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
 
   const openResult = await store.open(dbPath, config.ftsTokenizer);
   if (!openResult.ok) {
-    return { success: false, error: openResult.error.message };
+    return { ok: false, error: openResult.error.message };
+  }
+
+  return { ok: true, config, modelUri, store };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Main Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Execute gno embed command.
+ */
+export async function embed(options: EmbedOptions = {}): Promise<EmbedResult> {
+  const batchSize = options.batchSize ?? 32;
+  const force = options.force ?? false;
+  const dryRun = options.dryRun ?? false;
+
+  // Initialize config and store
+  const initResult = await initEmbedContext(options.configPath, options.model);
+  if (!initResult.ok) {
+    return { success: false, error: initResult.error };
   }
+  const { config, modelUri, store } = initResult;
 
   // Get raw DB for vector ops (SqliteAdapter always implements SqliteDbProvider)
   const db = store.getRawDb();

package/src/collection/add.ts

@@ -0,0 +1,113 @@
+/**
+ * Add collection core logic.
+ * Pure function that mutates config - caller handles I/O.
+ *
+ * @module src/collection/add
+ */
+
+import {
+  type Collection,
+  CollectionSchema,
+  DEFAULT_EXCLUDES,
+  DEFAULT_PATTERN,
+  pathExists,
+  toAbsolutePath,
+} from '../config';
+import type { Config } from '../config/types';
+import type { AddCollectionInput, CollectionResult } from './types';
+
+/**
+ * Parse comma-separated string or array into deduplicated array.
+ */
+function parseList(input: string[] | string | undefined): string[] {
+  if (!input) {
+    return [];
+  }
+  if (Array.isArray(input)) {
+    return [...new Set(input.map((s) => s.trim()).filter(Boolean))];
+  }
+  return [
+    ...new Set(
+      input
+        .split(',')
+        .map((s) => s.trim())
+        .filter(Boolean)
+    ),
+  ];
+}
+
+/**
+ * Add a collection to config.
+ *
+ * @param config - Current config (not mutated)
+ * @param input - Collection input
+ * @returns New config with collection added, or error
+ */
+export async function addCollection(
+  config: Config,
+  input: AddCollectionInput
+): Promise<CollectionResult> {
+  const collectionName = input.name.toLowerCase();
+
+  // Expand and validate path
+  const absolutePath = toAbsolutePath(input.path);
+
+  // Check if path exists
+  const exists = await pathExists(absolutePath);
+  if (!exists) {
+    return {
+      ok: false,
+      code: 'PATH_NOT_FOUND',
+      message: `Path does not exist: ${absolutePath}`,
+    };
+  }
+
+  // Check for duplicate name
+  const existing = config.collections.find((c) => c.name === collectionName);
+  if (existing) {
+    return {
+      ok: false,
+      code: 'DUPLICATE',
+      message: `Collection "${collectionName}" already exists`,
+    };
+  }
+
+  // Parse include/exclude lists
+  const includeList = parseList(input.include);
+  const excludeList =
+    parseList(input.exclude).length > 0
+      ? parseList(input.exclude)
+      : [...DEFAULT_EXCLUDES];
+
+  // Build collection
+  const collection: Collection = {
+    name: collectionName,
+    path: absolutePath,
+    pattern: input.pattern ?? DEFAULT_PATTERN,
+    include: includeList,
+    exclude: excludeList,
+    updateCmd: input.updateCmd,
+  };
+
+  // Validate collection
+  const validation = CollectionSchema.safeParse(collection);
+  if (!validation.success) {
+    return {
+      ok: false,
+      code: 'VALIDATION',
+      message: `Invalid collection: ${validation.error.issues[0]?.message ?? 'unknown error'}`,
+    };
+  }
+
+  // Create new config with collection added
+  const newConfig: Config = {
+    ...config,
+    collections: [...config.collections, validation.data],
+  };
+
+  return {
+    ok: true,
+    config: newConfig,
+    collection: validation.data,
+  };
+}

package/src/collection/index.ts

@@ -0,0 +1,17 @@
+/**
+ * Collection CRUD operations.
+ * Pure functions that mutate config - caller handles I/O.
+ *
+ * @module src/collection
+ */
+
+export { addCollection } from './add';
+export { removeCollection } from './remove';
+export type {
+  AddCollectionInput,
+  CollectionError,
+  CollectionResult,
+  CollectionSuccess,
+  RemoveCollectionInput,
+  RenameCollectionInput,
+} from './types';

package/src/collection/remove.ts

@@ -0,0 +1,65 @@
+/**
+ * Remove collection core logic.
+ * Pure function that mutates config - caller handles I/O.
+ *
+ * @module src/collection/remove
+ */
+
+import { getCollectionFromScope } from '../config';
+import type { Config } from '../config/types';
+import type { CollectionResult, RemoveCollectionInput } from './types';
+
+/**
+ * Remove a collection from config.
+ *
+ * @param config - Current config (not mutated)
+ * @param input - Collection name to remove
+ * @returns New config with collection removed, or error
+ */
+export function removeCollection(
+  config: Config,
+  input: RemoveCollectionInput
+): CollectionResult {
+  const collectionName = input.name.toLowerCase();
+
+  // Find collection
+  const collection = config.collections.find((c) => c.name === collectionName);
+  if (!collection) {
+    return {
+      ok: false,
+      code: 'NOT_FOUND',
+      message: `Collection "${collectionName}" not found`,
+    };
+  }
+
+  // Check if any contexts reference this collection
+  const referencingContexts = (config.contexts ?? []).filter((ctx) => {
+    const collFromScope = getCollectionFromScope(ctx.scopeKey);
+    return collFromScope === collectionName;
+  });
+
+  if (referencingContexts.length > 0) {
+    const scopes = referencingContexts.map((ctx) => ctx.scopeKey).join(', ');
+    return {
+      ok: false,
+      code: 'HAS_REFERENCES',
+      message: `Collection "${collectionName}" is referenced by contexts: ${scopes}. Remove the contexts first.`,
+    };
+  }
+
+  // Create new config with collection removed (filter instead of splice)
+  const newCollections = config.collections.filter(
+    (c) => c.name !== collectionName
+  );
+
+  const newConfig: Config = {
+    ...config,
+    collections: newCollections,
+  };
+
+  return {
+    ok: true,
+    config: newConfig,
+    collection,
+  };
+}

package/src/collection/types.ts

@@ -0,0 +1,70 @@
+/**
+ * Types for collection CRUD operations.
+ *
+ * @module src/collection/types
+ */
+
+import type { Collection, Config } from '../config/types';
+
+/**
+ * Input for adding a collection.
+ */
+export interface AddCollectionInput {
+  /** Absolute path to the folder */
+  path: string;
+  /** Collection name (will be lowercased) */
+  name: string;
+  /** File pattern (default: DEFAULT_PATTERN) */
+  pattern?: string;
+  /** Include patterns (comma-separated or array) */
+  include?: string[] | string;
+  /** Exclude patterns (comma-separated or array) */
+  exclude?: string[] | string;
+  /** Update command to run before sync */
+  updateCmd?: string;
+}
+
+/**
+ * Input for removing a collection.
+ */
+export interface RemoveCollectionInput {
+  /** Collection name (case-insensitive) */
+  name: string;
+}
+
+/**
+ * Input for renaming a collection.
+ */
+export interface RenameCollectionInput {
+  /** Current collection name (case-insensitive) */
+  oldName: string;
+  /** New collection name (case-insensitive) */
+  newName: string;
+}
+
+/**
+ * Successful collection operation result.
+ */
+export interface CollectionSuccess<T = Config> {
+  ok: true;
+  config: T;
+  collection: Collection;
+}
+
+/**
+ * Failed collection operation result.
+ */
+export interface CollectionError {
+  ok: false;
+  code:
+    | 'VALIDATION'
+    | 'NOT_FOUND'
+    | 'DUPLICATE'
+    | 'PATH_NOT_FOUND'
+    | 'HAS_REFERENCES';
+  message: string;
+}
+
+export type CollectionResult<T = Config> =
+  | CollectionSuccess<T>
+  | CollectionError;