@gmickel/gno 0.3.0

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

@@ -0,0 +1,120 @@
+/**
+ * gno collection add - Add a new collection
+ */
+
+import {
+  type Collection,
+  CollectionSchema,
+  DEFAULT_EXCLUDES,
+  DEFAULT_PATTERN,
+  loadConfig,
+  pathExists,
+  saveConfig,
+  toAbsolutePath,
+} from '../../../config';
+import { CliError } from '../../errors';
+
+interface AddOptions {
+  name?: string;
+  pattern?: string;
+  include?: string;
+  exclude?: string;
+  update?: string;
+}
+
+export async function collectionAdd(
+  path: string,
+  options: AddOptions
+): Promise<void> {
+  // Validate required name
+  if (!options.name) {
+    throw new CliError('VALIDATION', '--name is required');
+  }
+
+  const collectionName = options.name.toLowerCase();
+
+  // Expand and validate path
+  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) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to load config: ${result.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,
+    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'}`
+    );
+  }
+
+  // Add to config
+  config.collections.push(validation.data);
+
+  // Save config
+  const saveResult = await saveConfig(config);
+  if (!saveResult.ok) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to save config: ${saveResult.error.message}`
+    );
+  }
+
+  process.stdout.write(`Collection "${collectionName}" added successfully\n`);
+  process.stdout.write(`Path: ${absolutePath}\n`);
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Collection CLI commands
+ *
+ * @module src/cli/commands/collection
+ */
+
+export { collectionAdd } from './add';
+export { collectionList } from './list';
+export { collectionRemove } from './remove';
+export { collectionRename } from './rename';

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

@@ -0,0 +1,108 @@
+/**
+ * gno collection list - List all collections
+ */
+
+import type { Collection } from '../../../config';
+import { loadConfig } from '../../../config';
+import { bold, cyan, dim } from '../../colors';
+import { CliError } from '../../errors';
+
+/**
+ * Strip ANSI escape sequences and control characters from string.
+ * Prevents terminal injection from user-controlled config values.
+ */
+function sanitize(input: string): string {
+  // Strip ANSI escape sequences
+  // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional for sanitization
+  return input.replace(/\x1b\[[0-9;]*m/g, '').replace(/[\x00-\x1f\x7f]/g, '');
+}
+
+interface ListOptions {
+  json?: boolean;
+  md?: boolean;
+}
+
+function formatMarkdown(collections: Collection[]): string {
+  const lines: string[] = ['# Collections', ''];
+  if (collections.length === 0) {
+    lines.push('No collections configured.');
+    return lines.join('\n');
+  }
+
+  for (const coll of collections) {
+    lines.push(`## ${coll.name}`, '');
+    lines.push(`- **Path:** ${coll.path}`);
+    lines.push(`- **Pattern:** ${coll.pattern}`);
+    if (coll.include.length > 0) {
+      lines.push(`- **Include:** ${coll.include.join(', ')}`);
+    }
+    if (coll.exclude.length > 0) {
+      lines.push(`- **Exclude:** ${coll.exclude.join(', ')}`);
+    }
+    if (coll.updateCmd) {
+      lines.push(`- **Update Command:** \`${coll.updateCmd}\``);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+function formatTerminal(collections: Collection[]): string {
+  if (collections.length === 0) {
+    return dim('No collections configured.');
+  }
+
+  const lines: string[] = [
+    `${bold('Collections')} ${dim(`(${collections.length})`)}`,
+    '',
+  ];
+  for (const coll of collections) {
+    // Sanitize all user-controlled values to prevent terminal injection
+    const name = sanitize(coll.name);
+    const path = sanitize(coll.path);
+    const pattern = sanitize(coll.pattern);
+    const include = coll.include.map(sanitize);
+    const exclude = coll.exclude.map(sanitize);
+    const updateCmd = coll.updateCmd ? sanitize(coll.updateCmd) : undefined;
+
+    lines.push(`  ${cyan(bold(name))}`);
+    lines.push(`    ${dim('Path:')}    ${path}`);
+    lines.push(`    ${dim('Pattern:')} ${pattern}`);
+    if (include.length > 0) {
+      lines.push(`    ${dim('Include:')} ${include.join(', ')}`);
+    }
+    if (exclude.length > 0) {
+      lines.push(`    ${dim('Exclude:')} ${dim(exclude.join(', '))}`);
+    }
+    if (updateCmd) {
+      lines.push(`    ${dim('Update:')}  ${updateCmd}`);
+    }
+    lines.push('');
+  }
+  return lines.join('\n');
+}
+
+export async function collectionList(options: ListOptions): Promise<void> {
+  // Load config
+  const result = await loadConfig();
+  if (!result.ok) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to load config: ${result.error.message}`
+    );
+  }
+
+  const config = result.value;
+
+  // Format and output
+  let output: string;
+  if (options.json) {
+    output = JSON.stringify(config.collections, null, 2);
+  } else if (options.md) {
+    output = formatMarkdown(config.collections);
+  } else {
+    output = formatTerminal(config.collections);
+  }
+
+  process.stdout.write(`${output}\n`);
+}

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

@@ -0,0 +1,64 @@
+/**
+ * gno collection remove - Remove a collection
+ */
+
+import {
+  getCollectionFromScope,
+  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) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to load config: ${result.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`
+    );
+  }
+
+  // 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.`
+    );
+  }
+
+  // Remove collection
+  config.collections.splice(collectionIndex, 1);
+
+  // Save config
+  const saveResult = await saveConfig(config);
+  if (!saveResult.ok) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to save config: ${saveResult.error.message}`
+    );
+  }
+
+  process.stdout.write(`Collection "${collectionName}" removed successfully\n`);
+}

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

@@ -0,0 +1,95 @@
+/**
+ * gno collection rename - Rename a collection
+ */
+
+import {
+  CollectionSchema,
+  getCollectionFromScope,
+  loadConfig,
+  saveConfig,
+} from '../../../config';
+import { CliError } from '../../errors';
+
+export async function collectionRename(
+  oldName: string,
+  newName: 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}/`
+        );
+      }
+    }
+  }
+
+  // Save config
+  const saveResult = await saveConfig(config);
+  if (!saveResult.ok) {
+    throw new CliError(
+      'RUNTIME',
+      `Failed to save config: ${saveResult.error.message}`
+    );
+  }
+
+  process.stdout.write(
+    `Collection "${oldCollectionName}" renamed to "${newCollectionName}"\n`
+  );
+}

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

@@ -0,0 +1,67 @@
+/**
+ * CLI command: gno context add
+ *
+ * Add context metadata for a scope.
+ *
+ * @module src/cli/commands/context/add
+ */
+
+import { loadConfig, parseScope, saveConfig } from '../../../config';
+
+/**
+ * Exit codes
+ */
+const EXIT_SUCCESS = 0;
+const EXIT_VALIDATION = 1;
+
+/**
+ * Add context metadata for a scope.
+ *
+ * @param scope - Scope string (/, collection:, or gno://collection/path)
+ * @param text - Context description text
+ * @returns Exit code
+ */
+export async function contextAdd(scope: string, text: string): Promise<number> {
+  // Parse scope
+  const parsed = parseScope(scope);
+  if (!parsed) {
+    console.error(`Error: Invalid scope format: ${scope}`);
+    console.error(
+      'Valid formats: "/" (global), "name:" (collection), or "gno://collection/path" (prefix)'
+    );
+    return EXIT_VALIDATION;
+  }
+
+  // Load config
+  const configResult = await loadConfig();
+  if (!configResult.ok) {
+    console.error(`Error: ${configResult.error.message}`);
+    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}`);
+    return EXIT_VALIDATION;
+  }
+
+  console.log(`Added context for scope: ${scope}`);
+  return EXIT_SUCCESS;
+}

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

@@ -0,0 +1,153 @@
+/**
+ * CLI command: gno context check
+ *
+ * Validate context configuration.
+ *
+ * @module src/cli/commands/context/check
+ */
+
+import { getCollectionFromScope, loadConfig } from '../../../config';
+
+/**
+ * Exit codes
+ */
+const EXIT_SUCCESS = 0;
+
+/**
+ * Output format
+ */
+export type OutputFormat = 'terminal' | 'json' | 'md';
+
+/**
+ * Check result
+ */
+export interface CheckResult {
+  valid: boolean;
+  warnings: string[];
+  errors: string[];
+}
+
+/**
+ * Validate context configuration.
+ *
+ * Checks:
+ * - Global scope exists
+ * - Collection scopes reference existing collections
+ * - Prefix scopes reference existing collections
+ *
+ * @param format - Output format (terminal, json, md)
+ * @returns Exit code
+ */
+export async function contextCheck(
+  format: OutputFormat = 'terminal'
+): Promise<number> {
+  // Load config
+  const configResult = await loadConfig();
+  if (!configResult.ok) {
+    console.error(`Error: ${configResult.error.message}`);
+    return 1;
+  }
+
+  const { contexts, collections } = configResult.value;
+
+  const warnings: string[] = [];
+  const errors: string[] = [];
+
+  // Check global scope exists
+  const hasGlobalScope = contexts.some((ctx) => ctx.scopeType === 'global');
+  if (!hasGlobalScope) {
+    warnings.push('No global scope (/) configured');
+  }
+
+  // Check collection and prefix scopes reference existing collections
+  const collectionNames = new Set(collections.map((c) => c.name));
+
+  for (const ctx of contexts) {
+    const collectionName = getCollectionFromScope(ctx.scopeKey);
+    if (collectionName && !collectionNames.has(collectionName)) {
+      errors.push(
+        `Scope "${ctx.scopeKey}" references non-existent collection: ${collectionName}`
+      );
+    }
+  }
+
+  const result: CheckResult = {
+    valid: errors.length === 0,
+    warnings,
+    errors,
+  };
+
+  // Format and output
+  formatOutput(format, result);
+  return EXIT_SUCCESS;
+}
+
+/**
+ * Format and output check results
+ */
+function formatOutput(format: OutputFormat, result: CheckResult): void {
+  if (format === 'json') {
+    console.log(JSON.stringify(result, null, 2));
+    return;
+  }
+
+  if (format === 'md') {
+    formatMarkdown(result);
+    return;
+  }
+
+  formatTerminal(result);
+}
+
+/**
+ * Format check results as markdown
+ */
+function formatMarkdown(result: CheckResult): void {
+  console.log('# Context Check\n');
+  console.log(`**Valid:** ${result.valid}\n`);
+
+  if (result.errors.length > 0) {
+    console.log('## Errors\n');
+    for (const error of result.errors) {
+      console.log(`- ${error}`);
+    }
+    console.log('');
+  }
+
+  if (result.warnings.length > 0) {
+    console.log('## Warnings\n');
+    for (const warning of result.warnings) {
+      console.log(`- ${warning}`);
+    }
+    console.log('');
+  }
+
+  if (result.valid && result.warnings.length === 0) {
+    console.log('No issues found.');
+  }
+}
+
+/**
+ * Format check results for terminal
+ */
+function formatTerminal(result: CheckResult): void {
+  if (result.valid) {
+    console.log('✓ Context configuration is valid');
+  } else {
+    console.log('✗ Context configuration has errors');
+  }
+
+  if (result.errors.length > 0) {
+    console.log('\nErrors:');
+    for (const error of result.errors) {
+      console.log(`  - ${error}`);
+    }
+  }
+
+  if (result.warnings.length > 0) {
+    console.log('\nWarnings:');
+    for (const warning of result.warnings) {
+      console.log(`  - ${warning}`);
+    }
+  }
+}

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

@@ -0,0 +1,10 @@
+/**
+ * Context CLI commands.
+ *
+ * @module src/cli/commands/context
+ */
+
+export { contextAdd } from './add';
+export { type CheckResult, contextCheck, type OutputFormat } from './check';
+export { contextList } from './list';
+export { contextRm } from './rm';