@gmickel/gno 0.3.0

package/src/cli/commands/skill/show.ts

@@ -0,0 +1,73 @@
+/**
+ * Show/preview GNO skill files without installing.
+ *
+ * @module src/cli/commands/skill/show
+ */
+
+import { readdir } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { CliError } from '../../errors.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Source Path Resolution
+// ─────────────────────────────────────────────────────────────────────────────
+
+function getSkillSourceDir(): string {
+  const __dirname = dirname(fileURLToPath(import.meta.url));
+  return join(__dirname, '../../../../assets/skill');
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Show Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface ShowOptions {
+  file?: string;
+  all?: boolean;
+}
+
+const DEFAULT_FILE = 'SKILL.md';
+
+/**
+ * Show skill file content.
+ */
+export async function showSkill(opts: ShowOptions = {}): Promise<void> {
+  const sourceDir = getSkillSourceDir();
+
+  // Get available files
+  let files: string[];
+  try {
+    files = await readdir(sourceDir);
+  } catch {
+    throw new CliError('RUNTIME', `Skill files not found at ${sourceDir}`);
+  }
+
+  const mdFiles = files.filter((f) => f.endsWith('.md')).sort();
+
+  if (opts.all) {
+    // Show all files with separators
+    for (const file of mdFiles) {
+      process.stdout.write(`--- ${file} ---\n`);
+      const content = await Bun.file(join(sourceDir, file)).text();
+      process.stdout.write(`${content}\n`);
+      process.stdout.write('\n');
+    }
+  } else {
+    // Show single file
+    const fileName = opts.file ?? DEFAULT_FILE;
+
+    if (!mdFiles.includes(fileName)) {
+      throw new CliError(
+        'VALIDATION',
+        `Unknown file: ${fileName}. Available: ${mdFiles.join(', ')}`
+      );
+    }
+
+    const content = await Bun.file(join(sourceDir, fileName)).text();
+    process.stdout.write(`${content}\n`);
+  }
+
+  // Always list available files at end
+  process.stdout.write(`\nFiles: ${mdFiles.join(', ')}\n`);
+}

package/src/cli/commands/skill/uninstall.ts

@@ -0,0 +1,141 @@
+/**
+ * Uninstall GNO agent skill from Claude Code or Codex.
+ * Includes safety checks before deletion.
+ *
+ * @module src/cli/commands/skill/uninstall
+ */
+
+import { rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { CliError } from '../../errors.js';
+import { getGlobals } from '../../program.js';
+import {
+  resolveSkillPaths,
+  type SkillScope,
+  type SkillTarget,
+  validatePathForDeletion,
+} from './paths.js';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Uninstall Command
+// ─────────────────────────────────────────────────────────────────────────────
+
+export interface UninstallOptions {
+  scope?: SkillScope;
+  target?: SkillTarget | 'all';
+  /** Override for testing */
+  cwd?: string;
+  /** Override for testing */
+  homeDir?: string;
+  /** JSON output (defaults to globals.json) */
+  json?: boolean;
+  /** Quiet mode (defaults to globals.quiet) */
+  quiet?: boolean;
+}
+
+interface UninstallResult {
+  target: SkillTarget;
+  scope: SkillScope;
+  path: string;
+}
+
+/**
+ * Uninstall skill from a single target.
+ */
+async function uninstallFromTarget(
+  scope: SkillScope,
+  target: SkillTarget,
+  overrides?: { cwd?: string; homeDir?: string }
+): Promise<UninstallResult | null> {
+  const paths = resolveSkillPaths({ scope, target, ...overrides });
+
+  // Check if exists
+  const exists = await Bun.file(join(paths.gnoDir, 'SKILL.md')).exists();
+  if (!exists) {
+    return null;
+  }
+
+  // Safety validation
+  const validationError = validatePathForDeletion(paths.gnoDir, paths.base);
+  if (validationError) {
+    throw new CliError(
+      'RUNTIME',
+      `Safety check failed for ${paths.gnoDir}: ${validationError}`
+    );
+  }
+
+  // Remove directory
+  try {
+    await rm(paths.gnoDir, { recursive: true, force: true });
+    return { target, scope, path: paths.gnoDir };
+  } catch (err) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to remove skill: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+}
+
+/**
+ * Get globals with fallback for testing.
+ */
+function safeGetGlobals(): { json: boolean; quiet: boolean } {
+  try {
+    return getGlobals();
+  } catch {
+    return { json: false, quiet: false };
+  }
+}
+
+/**
+ * Uninstall GNO skill.
+ */
+export async function uninstallSkill(
+  opts: UninstallOptions = {}
+): Promise<void> {
+  const scope = opts.scope ?? 'project';
+  const target = opts.target ?? 'claude';
+  const globals = safeGetGlobals();
+  const json = opts.json ?? globals.json;
+  const quiet = opts.quiet ?? globals.quiet;
+
+  const targets: SkillTarget[] =
+    target === 'all' ? ['claude', 'codex'] : [target];
+
+  const results: UninstallResult[] = [];
+  const notFound: string[] = [];
+
+  for (const t of targets) {
+    const result = await uninstallFromTarget(scope, t, {
+      cwd: opts.cwd,
+      homeDir: opts.homeDir,
+    });
+    if (result) {
+      results.push(result);
+    } else {
+      notFound.push(t);
+    }
+  }
+
+  // If nothing was uninstalled
+  if (results.length === 0) {
+    throw new CliError(
+      'VALIDATION',
+      `GNO skill not found for ${targets.join(', ')} (${scope} scope)`
+    );
+  }
+
+  // Output
+  if (json) {
+    process.stdout.write(
+      `${JSON.stringify({ uninstalled: results }, null, 2)}\n`
+    );
+  } else if (!quiet) {
+    for (const r of results) {
+      process.stdout.write(`Uninstalled GNO skill from ${r.path}\n`);
+    }
+    if (notFound.length > 0) {
+      process.stdout.write(`(Not found for: ${notFound.join(', ')})\n`);
+    }
+  }
+}

package/src/cli/commands/status.ts

@@ -0,0 +1,205 @@
+/**
+ * gno status command implementation.
+ * Display index status and health information.
+ *
+ * @module src/cli/commands/status
+ */
+
+import { getIndexDbPath } from '../../app/constants';
+import { getConfigPaths, isInitialized, loadConfig } from '../../config';
+import { SqliteAdapter } from '../../store/sqlite/adapter';
+import type { IndexStatus } from '../../store/types';
+
+/**
+ * Options for status command.
+ */
+export interface StatusOptions {
+  /** Override config path */
+  configPath?: string;
+  /** Output as JSON */
+  json?: boolean;
+  /** Output as Markdown */
+  md?: boolean;
+}
+
+/**
+ * Result of status command.
+ */
+export type StatusResult =
+  | { success: true; status: IndexStatus }
+  | { success: false; error: string };
+
+/**
+ * Format status as terminal output.
+ */
+function formatTerminal(indexStatus: IndexStatus): string {
+  const lines: string[] = [];
+
+  lines.push(`Index: ${indexStatus.indexName}`);
+  lines.push(`Config: ${indexStatus.configPath}`);
+  lines.push(`Database: ${indexStatus.dbPath}`);
+  lines.push('');
+
+  if (indexStatus.collections.length === 0) {
+    lines.push('No collections configured.');
+  } else {
+    lines.push('Collections:');
+    for (const c of indexStatus.collections) {
+      lines.push(
+        `  ${c.name}: ${c.activeDocuments} docs, ${c.totalChunks} chunks` +
+          (c.embeddedChunks > 0 ? `, ${c.embeddedChunks} embedded` : '')
+      );
+    }
+  }
+
+  lines.push('');
+  lines.push(
+    `Total: ${indexStatus.activeDocuments} documents, ${indexStatus.totalChunks} chunks`
+  );
+
+  if (indexStatus.embeddingBacklog > 0) {
+    lines.push(`Embedding backlog: ${indexStatus.embeddingBacklog} chunks`);
+  }
+
+  if (indexStatus.recentErrors > 0) {
+    lines.push(`Recent errors: ${indexStatus.recentErrors} (last 24h)`);
+  }
+
+  if (indexStatus.lastUpdatedAt) {
+    lines.push(`Last updated: ${indexStatus.lastUpdatedAt}`);
+  }
+
+  lines.push(`Health: ${indexStatus.healthy ? 'OK' : 'DEGRADED'}`);
+
+  return lines.join('\n');
+}
+
+/**
+ * Format status as Markdown.
+ */
+function formatMarkdown(indexStatus: IndexStatus): string {
+  const lines: string[] = [];
+
+  lines.push(`# Index Status: ${indexStatus.indexName}`);
+  lines.push('');
+  lines.push(`- **Config**: ${indexStatus.configPath}`);
+  lines.push(`- **Database**: ${indexStatus.dbPath}`);
+  lines.push(`- **Health**: ${indexStatus.healthy ? '✓ OK' : '⚠ DEGRADED'}`);
+  lines.push('');
+
+  if (indexStatus.collections.length > 0) {
+    lines.push('## Collections');
+    lines.push('');
+    lines.push('| Name | Path | Docs | Chunks | Embedded |');
+    lines.push('|------|------|------|--------|----------|');
+    for (const c of indexStatus.collections) {
+      lines.push(
+        `| ${c.name} | ${c.path} | ${c.activeDocuments} | ${c.totalChunks} | ${c.embeddedChunks} |`
+      );
+    }
+    lines.push('');
+  }
+
+  lines.push('## Summary');
+  lines.push('');
+  lines.push(`- **Documents**: ${indexStatus.activeDocuments}`);
+  lines.push(`- **Chunks**: ${indexStatus.totalChunks}`);
+  lines.push(`- **Embedding backlog**: ${indexStatus.embeddingBacklog}`);
+  lines.push(`- **Recent errors**: ${indexStatus.recentErrors}`);
+
+  if (indexStatus.lastUpdatedAt) {
+    lines.push(`- **Last updated**: ${indexStatus.lastUpdatedAt}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Execute gno status command.
+ */
+export async function status(
+  options: StatusOptions = {}
+): Promise<StatusResult> {
+  // Check if initialized
+  const initialized = await isInitialized(options.configPath);
+  if (!initialized) {
+    return { success: false, error: 'GNO not initialized. Run: gno init' };
+  }
+
+  // Load config
+  const configResult = await loadConfig(options.configPath);
+  if (!configResult.ok) {
+    return { success: false, error: configResult.error.message };
+  }
+  const config = configResult.value;
+
+  // Open database
+  const store = new SqliteAdapter();
+  const dbPath = getIndexDbPath();
+  const paths = getConfigPaths();
+
+  // Set configPath for status output
+  store.setConfigPath(paths.configFile);
+
+  const openResult = await store.open(dbPath, config.ftsTokenizer);
+  if (!openResult.ok) {
+    return { success: false, error: openResult.error.message };
+  }
+
+  try {
+    const statusResult = await store.getStatus();
+    if (!statusResult.ok) {
+      return { success: false, error: statusResult.error.message };
+    }
+
+    return { success: true, status: statusResult.value };
+  } finally {
+    await store.close();
+  }
+}
+
+/**
+ * Format status result for output.
+ */
+export function formatStatus(
+  result: StatusResult,
+  options: StatusOptions
+): string {
+  if (!result.success) {
+    return options.json
+      ? JSON.stringify({ error: { code: 'RUNTIME', message: result.error } })
+      : `Error: ${result.error}`;
+  }
+
+  if (options.json) {
+    // Transform to match CLI spec output format
+    const s = result.status;
+    return JSON.stringify(
+      {
+        indexName: s.indexName,
+        configPath: s.configPath,
+        dbPath: s.dbPath,
+        collections: s.collections.map((c) => ({
+          name: c.name,
+          path: c.path,
+          documentCount: c.activeDocuments,
+          chunkCount: c.totalChunks,
+          embeddedCount: c.embeddedChunks,
+        })),
+        totalDocuments: s.activeDocuments,
+        totalChunks: s.totalChunks,
+        embeddingBacklog: s.embeddingBacklog,
+        lastUpdated: s.lastUpdatedAt,
+        healthy: s.healthy,
+      },
+      null,
+      2
+    );
+  }
+
+  if (options.md) {
+    return formatMarkdown(result.status);
+  }
+
+  return formatTerminal(result.status);
+}

package/src/cli/commands/update.ts

@@ -0,0 +1,68 @@
+/**
+ * gno update command implementation.
+ * Sync files from disk into the index (ingestion without embedding).
+ *
+ * @module src/cli/commands/update
+ */
+
+import { defaultSyncService, type SyncResult } from '../../ingestion';
+import { formatSyncResultLines, initStore } from './shared';
+
+/**
+ * Options for update command.
+ */
+export interface UpdateOptions {
+  /** Override config path */
+  configPath?: string;
+  /** Run git pull in git repositories before scanning */
+  gitPull?: boolean;
+  /** Verbose output */
+  verbose?: boolean;
+}
+
+/**
+ * Result of update command.
+ */
+export type UpdateResult =
+  | { success: true; result: SyncResult }
+  | { success: false; error: string };
+
+/**
+ * Execute gno update command.
+ */
+export async function update(
+  options: UpdateOptions = {}
+): Promise<UpdateResult> {
+  const initResult = await initStore({ configPath: options.configPath });
+  if (!initResult.ok) {
+    return { success: false, error: initResult.error };
+  }
+
+  const { store, collections } = initResult;
+
+  try {
+    // Run sync service
+    const result = await defaultSyncService.syncAll(collections, store, {
+      gitPull: options.gitPull,
+      runUpdateCmd: true,
+    });
+
+    return { success: true, result };
+  } finally {
+    await store.close();
+  }
+}
+
+/**
+ * Format update result for output.
+ */
+export function formatUpdate(
+  result: UpdateResult,
+  options: UpdateOptions
+): string {
+  if (!result.success) {
+    return `Error: ${result.error}`;
+  }
+
+  return formatSyncResultLines(result.result, options).join('\n');
+}

package/src/cli/commands/vsearch.ts

@@ -0,0 +1,188 @@
+/**
+ * gno vsearch command implementation.
+ * Vector semantic search over indexed documents.
+ *
+ * @module src/cli/commands/vsearch
+ */
+
+import { LlmAdapter } from '../../llm/nodeLlamaCpp/adapter';
+import { getActivePreset } from '../../llm/registry';
+import type { SearchOptions, SearchResults } from '../../pipeline/types';
+import {
+  searchVectorWithEmbedding,
+  type VectorSearchDeps,
+} from '../../pipeline/vsearch';
+import { createVectorIndexPort } from '../../store/vector';
+import {
+  type FormatOptions,
+  formatSearchResults,
+} from '../format/search-results';
+import { initStore } from './shared';
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Types
+// ─────────────────────────────────────────────────────────────────────────────
+
+export type VsearchCommandOptions = SearchOptions & {
+  /** Override config path */
+  configPath?: string;
+  /** Override model URI */
+  model?: string;
+  /** Output as JSON */
+  json?: boolean;
+  /** Output as Markdown */
+  md?: boolean;
+  /** Output as CSV */
+  csv?: boolean;
+  /** Output as XML */
+  xml?: boolean;
+  /** Output files only */
+  files?: boolean;
+};
+
+export type VsearchResult =
+  | { success: true; data: SearchResults }
+  | { success: false; error: string };
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Command Implementation
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Execute gno vsearch command.
+ */
+export async function vsearch(
+  query: string,
+  options: VsearchCommandOptions = {}
+): Promise<VsearchResult> {
+  // Adjust default limit based on output format
+  const isStructured =
+    options.json || options.files || options.csv || options.xml;
+  const limit = options.limit ?? (isStructured ? 20 : 5);
+
+  const initResult = await initStore({
+    configPath: options.configPath,
+    collection: options.collection,
+  });
+
+  if (!initResult.ok) {
+    return { success: false, error: initResult.error };
+  }
+
+  const { store, config } = initResult;
+
+  try {
+    // Get model URI from preset
+    const preset = getActivePreset(config);
+    const modelUri = options.model ?? preset.embed;
+
+    // Create LLM adapter for embeddings
+    const llm = new LlmAdapter(config);
+    const embedResult = await llm.createEmbeddingPort(modelUri);
+    if (!embedResult.ok) {
+      return { success: false, error: embedResult.error.message };
+    }
+
+    const embedPort = embedResult.value;
+
+    try {
+      // Embed query (also determines dimensions - avoids double embed)
+      const queryEmbedResult = await embedPort.embed(query);
+      if (!queryEmbedResult.ok) {
+        return { success: false, error: queryEmbedResult.error.message };
+      }
+      const queryEmbedding = new Float32Array(queryEmbedResult.value);
+      const dimensions = queryEmbedding.length;
+
+      // Create vector index port
+      const db = store.getRawDb();
+      const vectorResult = await createVectorIndexPort(db, {
+        model: modelUri,
+        dimensions,
+      });
+
+      if (!vectorResult.ok) {
+        return { success: false, error: vectorResult.error.message };
+      }
+
+      const vectorIndex = vectorResult.value;
+
+      const deps: VectorSearchDeps = {
+        store,
+        vectorIndex,
+        embedPort,
+        config,
+      };
+
+      // Pass pre-computed embedding to avoid double-embed
+      const result = await searchVectorWithEmbedding(
+        deps,
+        query,
+        queryEmbedding,
+        { ...options, limit }
+      );
+
+      if (!result.ok) {
+        return { success: false, error: result.error.message };
+      }
+
+      return { success: true, data: result.value };
+    } finally {
+      await embedPort.dispose();
+    }
+  } finally {
+    await store.close();
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────────────
+// Formatter
+// ─────────────────────────────────────────────────────────────────────────────
+
+/**
+ * Get output format from options.
+ */
+function getFormatType(
+  options: VsearchCommandOptions
+): FormatOptions['format'] {
+  if (options.json) {
+    return 'json';
+  }
+  if (options.files) {
+    return 'files';
+  }
+  if (options.csv) {
+    return 'csv';
+  }
+  if (options.md) {
+    return 'md';
+  }
+  if (options.xml) {
+    return 'xml';
+  }
+  return 'terminal';
+}
+
+/**
+ * Format vsearch result for output.
+ */
+export function formatVsearch(
+  result: VsearchResult,
+  options: VsearchCommandOptions
+): string {
+  if (!result.success) {
+    return options.json
+      ? JSON.stringify({
+          error: { code: 'QUERY_FAILED', message: result.error },
+        })
+      : `Error: ${result.error}`;
+  }
+
+  const formatOpts: FormatOptions = {
+    format: getFormatType(options),
+    full: options.full,
+    lineNumbers: options.lineNumbers,
+  };
+
+  return formatSearchResults(result.data, formatOpts);
+}