@gmickel/gno 0.9.1 → 0.9.3

package/src/cli/commands/completion/scripts.ts

@@ -0,0 +1,365 @@
+/**
+ * Shell completion scripts for bash, zsh, and fish.
+ *
+ * @module src/cli/commands/completion/scripts
+ */
+
+import { CLI_NAME } from "../../../app/constants.js";
+
+export type Shell = "bash" | "zsh" | "fish";
+export const SUPPORTED_SHELLS: Shell[] = ["bash", "zsh", "fish"];
+
+/**
+ * All gno commands and subcommands for completion.
+ */
+const COMMANDS = [
+  "init",
+  "index",
+  "update",
+  "embed",
+  "status",
+  "doctor",
+  "cleanup",
+  "reset",
+  "search",
+  "vsearch",
+  "query",
+  "ask",
+  "get",
+  "multi-get",
+  "ls",
+  "serve",
+  "mcp",
+  "mcp serve",
+  "mcp install",
+  "mcp uninstall",
+  "mcp status",
+  "collection",
+  "collection add",
+  "collection list",
+  "collection remove",
+  "collection rename",
+  "context",
+  "context add",
+  "context list",
+  "context check",
+  "context rm",
+  "models",
+  "models list",
+  "models pull",
+  "models clear",
+  "models path",
+  "models use",
+  "skill",
+  "skill install",
+  "skill uninstall",
+  "skill show",
+  "skill paths",
+  "completion",
+  "completion output",
+  "completion install",
+];
+
+/**
+ * Global flags available on all commands.
+ */
+const GLOBAL_FLAGS = [
+  "--index",
+  "--config",
+  "--no-color",
+  "--no-pager",
+  "--verbose",
+  "--yes",
+  "--quiet",
+  "--json",
+  "--offline",
+  "--help",
+  "--version",
+];
+
+/**
+ * Generate bash completion script.
+ */
+export function generateBashCompletion(): string {
+  const commands = COMMANDS.filter((c) => !c.includes(" ")).join(" ");
+  const subcommands: Record<string, string> = {};
+
+  for (const cmd of COMMANDS) {
+    if (cmd.includes(" ")) {
+      const parts = cmd.split(" ");
+      const parent = parts[0];
+      const sub = parts[1];
+      if (parent && sub) {
+        subcommands[parent] = subcommands[parent]
+          ? `${subcommands[parent]} ${sub}`
+          : sub;
+      }
+    }
+  }
+
+  const subCases = Object.entries(subcommands)
+    .map(
+      ([parent, subs]) =>
+        `      ${parent}) COMPREPLY=($(compgen -W "${subs}" -- "\${cur}")) ;;`
+    )
+    .join("\n");
+
+  return `# ${CLI_NAME} bash completion
+# Add to ~/.bashrc or ~/.bash_completion
+
+_${CLI_NAME}_completions() {
+  local cur prev cword
+  # Portable: don't rely on _init_completion (requires bash-completion package)
+  cur="\${COMP_WORDS[COMP_CWORD]}"
+  prev="\${COMP_WORDS[COMP_CWORD-1]}"
+  cword="\${COMP_CWORD}"
+
+  local commands="${commands}"
+  local global_flags="${GLOBAL_FLAGS.join(" ")}"
+
+  # Complete subcommands for parent commands
+  case "\${COMP_WORDS[1]}" in
+${subCases}
+  esac
+
+  # Complete global flags
+  if [[ "\${cur}" == -* ]]; then
+    COMPREPLY=($(compgen -W "\${global_flags}" -- "\${cur}"))
+    return
+  fi
+
+  # Complete top-level commands
+  if [[ \${cword} -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "\${commands}" -- "\${cur}"))
+    return
+  fi
+
+  # Dynamic collection completion for -c/--collection flag
+  if [[ "\${prev}" == "-c" || "\${prev}" == "--collection" ]]; then
+    local collections
+    collections=$(${CLI_NAME} collection list --json 2>/dev/null | grep -o '"name":"[^"]*"' | cut -d'"' -f4)
+    COMPREPLY=($(compgen -W "\${collections}" -- "\${cur}"))
+    return
+  fi
+}
+
+complete -F _${CLI_NAME}_completions ${CLI_NAME}
+`;
+}
+
+/**
+ * Generate zsh completion script.
+ */
+export function generateZshCompletion(): string {
+  const topLevel = COMMANDS.filter((c) => !c.includes(" "));
+  const subcommands: Record<string, string[]> = {};
+
+  for (const cmd of COMMANDS) {
+    if (cmd.includes(" ")) {
+      const parts = cmd.split(" ");
+      const parent = parts[0];
+      const sub = parts[1];
+      if (parent && sub) {
+        subcommands[parent] = subcommands[parent] || [];
+        subcommands[parent].push(sub);
+      }
+    }
+  }
+
+  const subCases = Object.entries(subcommands)
+    .map(
+      ([parent, subs]) =>
+        `    ${parent})
+      _arguments '2:subcommand:(${subs.join(" ")})'
+      ;;`
+    )
+    .join("\n");
+
+  return `# ${CLI_NAME} zsh completion
+# Add to ~/.zshrc or copy to a directory in $fpath
+# If autoloading from fpath, add "#compdef ${CLI_NAME}" as first line
+
+_${CLI_NAME}() {
+  local -a commands
+  commands=(
+${topLevel.map((c) => `    '${c}:${getCommandDescription(c)}'`).join("\n")}
+  )
+
+  local -a global_flags
+  global_flags=(
+    '--index[index name]:name:'
+    '--config[config file path]:file:_files'
+    '-c[filter by collection]:collection:_${CLI_NAME}_collections'
+    '--collection[filter by collection]:collection:_${CLI_NAME}_collections'
+    '--no-color[disable colors]'
+    '--no-pager[disable paging]'
+    '--verbose[verbose logging]'
+    '--yes[non-interactive mode]'
+    '--quiet[suppress non-essential output]'
+    '--json[JSON output]'
+    '--offline[offline mode]'
+    '--help[show help]'
+    '--version[show version]'
+  )
+
+  _arguments -C \\
+    "\${global_flags[@]}" \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case "$state" in
+    command)
+      _describe -t commands 'gno commands' commands
+      ;;
+    args)
+      # words[1] is the program name in zsh, words[2] is the command
+      case "\${words[2]}" in
+${subCases}
+      esac
+      ;;
+  esac
+}
+
+# Dynamic collection completion
+_${CLI_NAME}_collections() {
+  local -a collections
+  collections=(\${(f)"$($CLI_NAME collection list --json 2>/dev/null | grep -o '"name":"[^"]*"' | cut -d'"' -f4)"})
+  _describe -t collections 'collections' collections
+}
+
+# Register completion (works when sourced or autoloaded)
+(( $+functions[compdef] )) && compdef _${CLI_NAME} ${CLI_NAME}
+`;
+}
+
+/**
+ * Generate fish completion script.
+ */
+export function generateFishCompletion(): string {
+  const topLevel = COMMANDS.filter((c) => !c.includes(" "));
+  const subcommands: Record<string, string[]> = {};
+
+  for (const cmd of COMMANDS) {
+    if (cmd.includes(" ")) {
+      const parts = cmd.split(" ");
+      const parent = parts[0];
+      const sub = parts[1];
+      if (parent && sub) {
+        subcommands[parent] = subcommands[parent] || [];
+        subcommands[parent].push(sub);
+      }
+    }
+  }
+
+  const topLevelCompletions = topLevel
+    .map(
+      (c) =>
+        `complete -c ${CLI_NAME} -f -n "__fish_use_subcommand" -a "${c}" -d "${getCommandDescription(c)}"`
+    )
+    .join("\n");
+
+  const subCompletions = Object.entries(subcommands)
+    .flatMap(([parent, subs]) =>
+      subs.map(
+        (sub) =>
+          `complete -c ${CLI_NAME} -f -n "__fish_seen_subcommand_from ${parent}" -a "${sub}" -d "${getCommandDescription(`${parent} ${sub}`)}"`
+      )
+    )
+    .join("\n");
+
+  return `# ${CLI_NAME} fish completion
+# Copy to ~/.config/fish/completions/${CLI_NAME}.fish
+
+# Disable file completion by default
+complete -c ${CLI_NAME} -f
+
+# Global flags
+complete -c ${CLI_NAME} -l index -d "index name" -r
+complete -c ${CLI_NAME} -l config -d "config file path" -r
+complete -c ${CLI_NAME} -l no-color -d "disable colors"
+complete -c ${CLI_NAME} -l verbose -d "verbose logging"
+complete -c ${CLI_NAME} -l yes -d "non-interactive mode"
+complete -c ${CLI_NAME} -l quiet -d "suppress non-essential output"
+complete -c ${CLI_NAME} -l json -d "JSON output"
+complete -c ${CLI_NAME} -l offline -d "offline mode"
+complete -c ${CLI_NAME} -s h -l help -d "show help"
+complete -c ${CLI_NAME} -s V -l version -d "show version"
+
+# Top-level commands
+${topLevelCompletions}
+
+# Subcommands
+${subCompletions}
+
+# Dynamic collection completion for -c/--collection
+complete -c ${CLI_NAME} -s c -l collection -d "filter by collection" -xa "(${CLI_NAME} collection list --json 2>/dev/null | string match -r '"name":"[^"]*"' | string replace -r '"name":"([^"]*)"' '$1')"
+`;
+}
+
+/**
+ * Get script for a specific shell.
+ */
+export function getCompletionScript(shell: Shell): string {
+  switch (shell) {
+    case "bash":
+      return generateBashCompletion();
+    case "zsh":
+      return generateZshCompletion();
+    case "fish":
+      return generateFishCompletion();
+  }
+}
+
+/**
+ * Get brief description for a command.
+ */
+function getCommandDescription(cmd: string): string {
+  const descriptions: Record<string, string> = {
+    init: "Initialize GNO configuration",
+    index: "Index files from collections",
+    update: "Sync files from disk",
+    embed: "Generate embeddings",
+    status: "Show index status",
+    doctor: "Diagnose configuration issues",
+    cleanup: "Clean orphaned data",
+    reset: "Delete all GNO data",
+    search: "BM25 keyword search",
+    vsearch: "Vector similarity search",
+    query: "Hybrid search with reranking",
+    ask: "Query with grounded answer",
+    get: "Get document by URI",
+    "multi-get": "Get multiple documents",
+    ls: "List indexed documents",
+    serve: "Start web UI server",
+    mcp: "MCP server and configuration",
+    "mcp serve": "Start MCP server",
+    "mcp install": "Install MCP server to client",
+    "mcp uninstall": "Remove MCP server from client",
+    "mcp status": "Show MCP installation status",
+    collection: "Manage collections",
+    "collection add": "Add a collection",
+    "collection list": "List collections",
+    "collection remove": "Remove a collection",
+    "collection rename": "Rename a collection",
+    context: "Manage context items",
+    "context add": "Add context metadata",
+    "context list": "List context items",
+    "context check": "Check context configuration",
+    "context rm": "Remove context item",
+    models: "Manage LLM models",
+    "models list": "List available models",
+    "models pull": "Download models",
+    "models clear": "Clear model cache",
+    "models path": "Show model cache path",
+    "models use": "Switch active model preset",
+    skill: "Manage GNO agent skill",
+    "skill install": "Install GNO skill",
+    "skill uninstall": "Uninstall GNO skill",
+    "skill show": "Preview skill files",
+    "skill paths": "Show skill installation paths",
+    completion: "Shell completion scripts",
+    "completion output": "Output completion script",
+    "completion install": "Install shell completions",
+  };
+  return descriptions[cmd] || cmd;
+}

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

@@ -1,6 +1,7 @@
 /**
  * Path resolution for skill installation.
  * Supports Claude Code and Codex targets with project/user scopes.
+ * Note: OpenCode and Amp use the same .claude path as Claude Code.
  *
  * @module src/cli/commands/skill/paths
  */
@@ -28,6 +29,8 @@ export const ENV_CODEX_SKILLS_DIR = "CODEX_SKILLS_DIR";
 export type SkillScope = "project" | "user";
 export type SkillTarget = "claude" | "codex";
 
+export const SKILL_TARGETS: SkillTarget[] = ["claude", "codex"];
+
 export interface SkillPathOptions {
   scope: SkillScope;
   target: SkillTarget;
@@ -53,13 +56,27 @@ export interface SkillPaths {
 /** Skill name for the gno skill directory */
 export const SKILL_NAME = "gno";
 
-/** Directory name for skills within agent config */
-const SKILLS_SUBDIR = "skills";
+/** Path configuration per target */
+interface TargetPathConfig {
+  projectBase: string; // e.g., ".claude"
+  userBase: string; // e.g., ".claude" (joined with homedir) or ".config/opencode"
+  skillsSubdir: string; // e.g., "skills" or "skill"
+  envVar: string;
+}
 
-/** Agent config directory names */
-const AGENT_DIRS: Record<SkillTarget, string> = {
-  claude: ".claude",
-  codex: ".codex",
+const TARGET_CONFIGS: Record<SkillTarget, TargetPathConfig> = {
+  claude: {
+    projectBase: ".claude",
+    userBase: ".claude",
+    skillsSubdir: "skills",
+    envVar: ENV_CLAUDE_SKILLS_DIR,
+  },
+  codex: {
+    projectBase: ".codex",
+    userBase: ".codex",
+    skillsSubdir: "skills",
+    envVar: ENV_CODEX_SKILLS_DIR,
+  },
 };
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -71,19 +88,15 @@ const AGENT_DIRS: Record<SkillTarget, string> = {
  */
 export function resolveSkillPaths(opts: SkillPathOptions): SkillPaths {
   const { scope, target, cwd, homeDir } = opts;
+  const config = TARGET_CONFIGS[target];
 
   // Check for env overrides first
-  const envOverride =
-    target === "claude"
-      ? process.env[ENV_CLAUDE_SKILLS_DIR]
-      : process.env[ENV_CODEX_SKILLS_DIR];
+  const envOverride = process.env[config.envVar];
 
   if (envOverride) {
     // Require absolute path for security
     if (!isAbsolute(envOverride)) {
-      throw new Error(
-        `${target === "claude" ? ENV_CLAUDE_SKILLS_DIR : ENV_CODEX_SKILLS_DIR} must be an absolute path`
-      );
+      throw new Error(`${config.envVar} must be an absolute path`);
     }
     const skillsDir = normalize(envOverride);
     return {
@@ -94,18 +107,17 @@ export function resolveSkillPaths(opts: SkillPathOptions): SkillPaths {
   }
 
   // Resolve base directory
-  const agentDir = AGENT_DIRS[target];
   let base: string;
 
   if (scope === "user") {
     const home = homeDir ?? process.env[ENV_SKILLS_HOME_OVERRIDE] ?? homedir();
-    base = join(home, agentDir);
+    base = join(home, config.userBase);
   } else {
     const projectRoot = cwd ?? process.cwd();
-    base = join(projectRoot, agentDir);
+    base = join(projectRoot, config.projectBase);
   }
 
-  const skillsDir = join(base, SKILLS_SUBDIR);
+  const skillsDir = join(base, config.skillsSubdir);
   const gnoDir = join(skillsDir, SKILL_NAME);
 
   return { base, skillsDir, gnoDir };
@@ -120,8 +132,7 @@ export function resolveAllPaths(
   overrides?: { cwd?: string; homeDir?: string }
 ): Array<{ scope: SkillScope; target: SkillTarget; paths: SkillPaths }> {
   const scopes: SkillScope[] = scope === "all" ? ["project", "user"] : [scope];
-  const targets: SkillTarget[] =
-    target === "all" ? ["claude", "codex"] : [target];
+  const targets: SkillTarget[] = target === "all" ? SKILL_TARGETS : [target];
 
   const results: Array<{
     scope: SkillScope;
@@ -147,11 +158,16 @@ export function resolveAllPaths(
 // ─────────────────────────────────────────────────────────────────────────────
 
 /**
- * Expected path suffix for gno skill directory.
- * Platform-aware (handles Windows backslash).
+ * Get expected path suffixes for gno skill directory.
+ * Returns all valid suffixes since different targets use different subdir names.
  */
-function getExpectedSuffix(): string {
-  return `${sep}${SKILLS_SUBDIR}${sep}${SKILL_NAME}`;
+function getExpectedSuffixes(): string[] {
+  const subdirs = new Set(
+    Object.values(TARGET_CONFIGS).map((c) => c.skillsSubdir)
+  );
+  return Array.from(subdirs).map(
+    (subdir) => `${sep}${subdir}${sep}${SKILL_NAME}`
+  );
 }
 
 /**
@@ -164,11 +180,14 @@ export function validatePathForDeletion(
 ): string | null {
   const normalized = normalize(destDir);
   const normalizedBase = normalize(base);
-  const expectedSuffix = getExpectedSuffix();
-
-  // Must end with /skills/gno (or \skills\gno on Windows)
-  if (!normalized.endsWith(expectedSuffix)) {
-    return `Path does not end with expected suffix (${expectedSuffix})`;
+  const expectedSuffixes = getExpectedSuffixes();
+
+  // Must end with /skills/gno or /skill/gno (platform-aware)
+  const hasValidSuffix = expectedSuffixes.some((suffix) =>
+    normalized.endsWith(suffix)
+  );
+  if (!hasValidSuffix) {
+    return `Path does not end with expected suffix (${expectedSuffixes.join(" or ")})`;
   }
 
   // Minimum length sanity check

package/src/cli/context.ts

@@ -21,6 +21,7 @@ export interface GlobalOptions {
   quiet: boolean;
   json: boolean;
   offline: boolean;
+  noPager: boolean;
 }
 
 // ─────────────────────────────────────────────────────────────────────────────
@@ -58,6 +59,8 @@ export function parseGlobalOptions(
     quiet: Boolean(raw.quiet),
     json: Boolean(raw.json),
     offline: offlineEnabled,
+    // Commander: --no-pager => opts().pager === false
+    noPager: raw.pager === false,
   };
 }