@gmickel/gno 0.3.0

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

@@ -0,0 +1,199 @@
+/**
+ * gno models pull command implementation.
+ * Download models to local cache.
+ *
+ * @module src/cli/commands/models/pull
+ */
+
+import { getModelsCachePath } from '../../../app/constants';
+import { loadConfig } from '../../../config';
+import { ModelCache } from '../../../llm/cache';
+import { getActivePreset } from '../../../llm/registry';
+import type { DownloadProgress, ModelType } from '../../../llm/types';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface ModelsPullOptions {
+  /** Override config path */
+  configPath?: string;
+  /** Pull all models */
+  all?: boolean;
+  /** Pull embedding model */
+  embed?: boolean;
+  /** Pull reranker model */
+  rerank?: boolean;
+  /** Pull generation model */
+  gen?: boolean;
+  /** Force re-download */
+  force?: boolean;
+  /** Progress callback for UI (omit to disable progress) */
+  onProgress?: (type: ModelType, progress: DownloadProgress) => void;
+}
+
+export interface ModelPullResult {
+  type: ModelType;
+  uri: string;
+  ok: boolean;
+  error?: string;
+  path?: string;
+  skipped?: boolean;
+}
+
+export interface ModelsPullResult {
+  results: ModelPullResult[];
+  failed: number;
+  skipped: number;
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Determine which model types to pull based on options.
+ */
+function getTypesToPull(options: ModelsPullOptions): ModelType[] {
+  if (options.all) {
+    return ['embed', 'rerank', 'gen'];
+  }
+  if (options.embed || options.rerank || options.gen) {
+    const types: ModelType[] = [];
+    if (options.embed) {
+      types.push('embed');
+    }
+    if (options.rerank) {
+      types.push('rerank');
+    }
+    if (options.gen) {
+      types.push('gen');
+    }
+    return types;
+  }
+  // Default: pull all
+  return ['embed', 'rerank', 'gen'];
+}
+
+/**
+ * Execute gno models pull command.
+ */
+export async function modelsPull(
+  options: ModelsPullOptions = {}
+): Promise<ModelsPullResult> {
+  // Load config (use defaults if not initialized)
+  const { createDefaultConfig } = await import('../../../config');
+  const configResult = await loadConfig(options.configPath);
+  const config = configResult.ok ? configResult.value : createDefaultConfig();
+
+  const preset = getActivePreset(config);
+  const cache = new ModelCache(getModelsCachePath());
+  const types = getTypesToPull(options);
+
+  const results: ModelPullResult[] = [];
+  let failed = 0;
+  let skipped = 0;
+
+  for (const type of types) {
+    const uri = preset[type];
+
+    // Check if already cached (skip unless --force)
+    if (!options.force) {
+      const isCached = await cache.isCached(uri);
+      if (isCached) {
+        const path = await cache.getCachedPath(uri);
+        results.push({
+          type,
+          uri,
+          ok: true,
+          path: path ?? undefined,
+          skipped: true,
+        });
+        skipped += 1;
+        continue;
+      }
+    }
+
+    // Download the model
+    const result = await cache.download(
+      uri,
+      type,
+      (progress) => {
+        options.onProgress?.(type, progress);
+      },
+      options.force
+    );
+
+    if (result.ok) {
+      results.push({
+        type,
+        uri,
+        ok: true,
+        path: result.value,
+      });
+    } else {
+      results.push({
+        type,
+        uri,
+        ok: false,
+        error: result.error.message,
+      });
+      failed += 1;
+    }
+  }
+
+  return { results, failed, skipped };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Formatting
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Format models pull result for output.
+ */
+export function formatModelsPull(result: ModelsPullResult): string {
+  const lines: string[] = [];
+
+  for (const r of result.results) {
+    if (r.ok) {
+      if (r.skipped) {
+        lines.push(`${r.type}: skipped (already cached)`);
+      } else {
+        lines.push(`${r.type}: downloaded`);
+      }
+    } else {
+      lines.push(`${r.type}: failed - ${r.error}`);
+    }
+  }
+
+  if (result.failed > 0) {
+    lines.push('');
+    lines.push(`${result.failed} model(s) failed to download.`);
+  } else if (result.skipped === result.results.length) {
+    lines.push('');
+    lines.push('All models already cached. Use --force to re-download.');
+  } else {
+    lines.push('');
+    lines.push('All models downloaded successfully.');
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Create a terminal progress renderer.
+ */
+export function createProgressRenderer(): (
+  type: ModelType,
+  progress: DownloadProgress
+) => void {
+  return (type, progress) => {
+    const percent = progress.percent.toFixed(1);
+    const downloaded = (progress.downloadedBytes / 1024 / 1024).toFixed(1);
+    const total = (progress.totalBytes / 1024 / 1024).toFixed(1);
+    process.stderr.write(
+      `\r${type}: ${percent}% (${downloaded}/${total} MB)    `
+    );
+  };
+}

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

@@ -0,0 +1,85 @@
+/**
+ * gno models use command implementation.
+ * Switch active model preset.
+ *
+ * @module src/cli/commands/models/use
+ */
+
+import { createDefaultConfig, loadConfig } from '../../../config';
+import { saveConfig } from '../../../config/saver';
+import { getPreset, listPresets } from '../../../llm/registry';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface ModelsUseOptions {
+  /** Override config path */
+  configPath?: string;
+}
+
+export type ModelsUseResult =
+  | { success: true; preset: string; name: string }
+  | { success: false; error: string };
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Execute gno models use command.
+ */
+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();
+
+  // 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,
+      warmModelTtl: config.models?.warmModelTtl ?? 300_000,
+    },
+  };
+
+  // Save updated config
+  const saveResult = await saveConfig(updatedConfig, options.configPath);
+  if (!saveResult.ok) {
+    return {
+      success: false,
+      error: `Failed to save config: ${saveResult.error.message}`,
+    };
+  }
+
+  return { success: true, preset: presetId, name: preset.name };
+}
+
+/**
+ * Format models use result for output.
+ */
+export function formatModelsUse(result: ModelsUseResult): string {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+  return `Switched to preset: ${result.preset} (${result.name})`;
+}

package/src/cli/commands/multi-get.ts

@@ -0,0 +1,400 @@
+/**
+ * gno multi-get command implementation.
+ * Retrieve multiple documents by reference.
+ *
+ * @module src/cli/commands/multi-get
+ */
+
+import { minimatch } from 'minimatch';
+import type { DocumentRow, StorePort, StoreResult } from '../../store/types';
+import type { ParsedRef } from './ref-parser';
+import { isGlobPattern, parseRef, splitRefs } from './ref-parser';
+import { initStore } from './shared';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface MultiGetCommandOptions {
+  /** Override config path */
+  configPath?: string;
+  /** Max bytes per document (default 10240) */
+  maxBytes?: number;
+  /** Include line numbers */
+  lineNumbers?: boolean;
+  /** JSON output */
+  json?: boolean;
+  /** File protocol output */
+  files?: boolean;
+  /** Markdown output */
+  md?: boolean;
+}
+
+export type MultiGetResult =
+  | { success: true; data: MultiGetResponse }
+  | { success: false; error: string; isValidation?: boolean };
+
+export interface MultiGetDocument {
+  docid: string;
+  uri: string;
+  title?: string;
+  content: string;
+  truncated?: boolean;
+  totalLines?: number;
+  source: { absPath?: string; relPath: string; mime: string; ext: string };
+}
+
+export interface SkippedDoc {
+  ref: string;
+  reason: 'not_found' | 'conversion_error' | 'invalid_ref';
+}
+
+export interface MultiGetResponse {
+  documents: MultiGetDocument[];
+  skipped: SkippedDoc[];
+  meta: {
+    requested: number;
+    returned: number;
+    skipped: number;
+    maxBytes?: number;
+  };
+}
+
+interface ConfigLike {
+  collections: { name: string; path: string }[];
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Document Lookup Helper
+// ─────────────────────────────────────────────────────────────────────────────
+
+function lookupDocument(
+  store: StorePort,
+  parsed: ParsedRef
+): Promise<StoreResult<DocumentRow | null>> {
+  switch (parsed.type) {
+    case 'docid':
+      return store.getDocumentByDocid(parsed.value);
+    case 'uri':
+      return store.getDocumentByUri(parsed.value);
+    case 'collPath':
+      if (!(parsed.collection && parsed.relPath)) {
+        return Promise.resolve({ ok: true as const, value: null });
+      }
+      return store.getDocument(parsed.collection, parsed.relPath);
+    default:
+      return Promise.resolve({ ok: true as const, value: null });
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Glob Expansion
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface ExpandResult {
+  expanded: string[];
+  invalidRefs: string[];
+}
+
+async function expandGlobs(
+  refs: string[],
+  store: StorePort
+): Promise<ExpandResult> {
+  const expanded: string[] = [];
+  const invalidRefs: string[] = [];
+
+  for (const ref of refs) {
+    if (!isGlobPattern(ref)) {
+      expanded.push(ref);
+      continue;
+    }
+
+    const slashIdx = ref.indexOf('/');
+    if (slashIdx === -1) {
+      invalidRefs.push(ref);
+      continue;
+    }
+
+    const collection = ref.slice(0, slashIdx);
+    const pattern = ref.slice(slashIdx + 1);
+    const listResult = await store.listDocuments(collection);
+
+    if (listResult.ok) {
+      for (const doc of listResult.value) {
+        if (doc.active && minimatch(doc.relPath, pattern)) {
+          expanded.push(`${collection}/${doc.relPath}`);
+        }
+      }
+    }
+  }
+
+  return { expanded, invalidRefs };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Content Truncation
+// ─────────────────────────────────────────────────────────────────────────────
+
+const encoder = new TextEncoder();
+
+function truncateContent(
+  content: string,
+  maxBytes: number
+): { content: string; truncated: boolean } {
+  if (encoder.encode(content).length <= maxBytes) {
+    return { content, truncated: false };
+  }
+
+  const lines = content.split('\n');
+  let accumulated = '';
+  let byteLen = 0;
+
+  for (const line of lines) {
+    const lineBytes = encoder.encode(`${line}\n`).length;
+    if (byteLen + lineBytes > maxBytes) {
+      return { content: accumulated.trimEnd(), truncated: true };
+    }
+    accumulated += `${line}\n`;
+    byteLen += lineBytes;
+  }
+
+  return { content: accumulated.trimEnd(), truncated: false };
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Document Fetching
+// ─────────────────────────────────────────────────────────────────────────────
+
+interface FetchContext {
+  store: StorePort;
+  config: ConfigLike;
+  maxBytes: number;
+  documents: MultiGetDocument[];
+  skipped: SkippedDoc[];
+  seen: Set<string>;
+}
+
+async function fetchSingleDocument(
+  ref: string,
+  ctx: FetchContext
+): Promise<void> {
+  if (ctx.seen.has(ref)) {
+    return;
+  }
+  ctx.seen.add(ref);
+
+  const parsed = parseRef(ref);
+  if ('error' in parsed) {
+    ctx.skipped.push({ ref, reason: 'invalid_ref' });
+    return;
+  }
+
+  const docResult = await lookupDocument(ctx.store, parsed);
+  if (!docResult.ok) {
+    ctx.skipped.push({ ref, reason: 'not_found' });
+    return;
+  }
+
+  const doc = docResult.value;
+  if (!doc?.active) {
+    ctx.skipped.push({ ref, reason: 'not_found' });
+    return;
+  }
+
+  if (!doc.mirrorHash) {
+    ctx.skipped.push({ ref, reason: 'conversion_error' });
+    return;
+  }
+
+  const contentResult = await ctx.store.getContent(doc.mirrorHash);
+  if (!contentResult.ok || contentResult.value === null) {
+    ctx.skipped.push({ ref, reason: 'conversion_error' });
+    return;
+  }
+
+  const { content, truncated } = truncateContent(
+    contentResult.value,
+    ctx.maxBytes
+  );
+  const coll = ctx.config.collections.find((c) => c.name === doc.collection);
+
+  ctx.documents.push({
+    docid: doc.docid,
+    uri: doc.uri,
+    title: doc.title ?? undefined,
+    content,
+    truncated: truncated || undefined,
+    totalLines: content.split('\n').length,
+    source: {
+      absPath: coll ? `${coll.path}/${doc.relPath}` : undefined,
+      relPath: doc.relPath,
+      mime: doc.sourceMime,
+      ext: doc.sourceExt,
+    },
+  });
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Command Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Execute gno multi-get command.
+ */
+export async function multiGet(
+  refs: string[],
+  options: MultiGetCommandOptions = {}
+): Promise<MultiGetResult> {
+  const maxBytes = options.maxBytes ?? 10_240;
+  const allRefs = splitRefs(refs);
+
+  const initResult = await initStore({ configPath: options.configPath });
+  if (!initResult.ok) {
+    return { success: false, error: initResult.error };
+  }
+  const { store, config } = initResult;
+
+  try {
+    const { expanded: expandedRefs, invalidRefs } = await expandGlobs(
+      allRefs,
+      store
+    );
+    const ctx: FetchContext = {
+      store,
+      config,
+      maxBytes,
+      documents: [],
+      skipped: [],
+      seen: new Set(),
+    };
+
+    // Track invalid refs as skipped
+    for (const ref of invalidRefs) {
+      ctx.skipped.push({ ref, reason: 'invalid_ref' });
+    }
+
+    for (const ref of expandedRefs) {
+      await fetchSingleDocument(ref, ctx);
+    }
+
+    const totalRequested = expandedRefs.length + invalidRefs.length;
+    return {
+      success: true,
+      data: {
+        documents: ctx.documents,
+        skipped: ctx.skipped,
+        meta: {
+          requested: totalRequested,
+          returned: ctx.documents.length,
+          skipped: ctx.skipped.length,
+          maxBytes,
+        },
+      },
+    };
+  } finally {
+    await store.close();
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Formatter
+// ─────────────────────────────────────────────────────────────────────────────
+
+function addLineNumbers(text: string, startLine = 1): string {
+  return text
+    .split('\n')
+    .map((line, i) => `${startLine + i}: ${line}`)
+    .join('\n');
+}
+
+function formatContent(content: string, lineNumbers: boolean): string {
+  return lineNumbers ? addLineNumbers(content) : content;
+}
+
+function formatMarkdown(
+  data: MultiGetResponse,
+  options: MultiGetCommandOptions
+): string {
+  const lines: string[] = [];
+  lines.push('# Multi-Get Results');
+  lines.push('');
+  lines.push(`*${data.meta.returned} of ${data.meta.requested} documents*`);
+  lines.push('');
+
+  for (const doc of data.documents) {
+    lines.push(`## ${doc.title || doc.source.relPath}`);
+    lines.push(`- **URI**: \`${doc.uri}\``);
+    if (doc.truncated) {
+      lines.push(`- **Truncated**: yes (max ${data.meta.maxBytes} bytes)`);
+    }
+    lines.push('');
+    lines.push('```');
+    lines.push(formatContent(doc.content, Boolean(options.lineNumbers)));
+    lines.push('```');
+    lines.push('');
+  }
+
+  if (data.skipped.length > 0) {
+    lines.push('## Skipped');
+    for (const s of data.skipped) {
+      lines.push(`- ${s.ref}: ${s.reason}`);
+    }
+  }
+
+  return lines.join('\n');
+}
+
+function formatTerminal(
+  data: MultiGetResponse,
+  options: MultiGetCommandOptions
+): string {
+  const lines: string[] = [];
+
+  for (const doc of data.documents) {
+    lines.push(`=== ${doc.uri} ===`);
+    lines.push(formatContent(doc.content, Boolean(options.lineNumbers)));
+    lines.push('');
+  }
+
+  if (data.skipped.length > 0) {
+    lines.push(`Skipped: ${data.skipped.map((s) => s.ref).join(', ')}`);
+  }
+
+  lines.push(
+    `${data.meta.returned}/${data.meta.requested} documents retrieved`
+  );
+  return lines.join('\n');
+}
+
+/**
+ * Format multi-get result for output.
+ */
+export function formatMultiGet(
+  result: MultiGetResult,
+  options: MultiGetCommandOptions
+): string {
+  if (!result.success) {
+    if (options.json) {
+      return JSON.stringify({
+        error: { code: 'MULTI_GET_FAILED', message: result.error },
+      });
+    }
+    return `Error: ${result.error}`;
+  }
+
+  const { data } = result;
+
+  if (options.json) {
+    return JSON.stringify(data, null, 2);
+  }
+
+  if (options.files) {
+    return data.documents.map((d) => `${d.docid},${d.uri}`).join('\n');
+  }
+
+  if (options.md) {
+    return formatMarkdown(data, options);
+  }
+
+  return formatTerminal(data, options);
+}