superacli 1.1.26 → 1.1.28

package/TAG_VOCABULARY.md

@@ -0,0 +1,217 @@
+# SuperCLI Tag Vocabulary
+
+Standardized tags for categorizing and discovering plugins.
+
+## Language Tags
+- `bash` — Bash shell
+- `c` — C language
+- `cpp` — C++ language
+- `csharp` — C# language
+- `go` — Go language
+- `java` — Java language
+- `javascript` — JavaScript language
+- `python` — Python language
+- `rust` — Rust language
+- `typescript` — TypeScript language
+- `lua` — Lua language
+- `ruby` — Ruby language
+- `php` — PHP language
+
+## Category: Development
+
+### Build & Compilation
+- `build` — Build tools and systems
+- `compiler` — Language compilers
+- `bundler` — Code bundling tools
+- `transpiler` — Code transpilers
+
+### Testing & Quality
+- `testing` — Testing frameworks
+- `unit-testing` — Unit test tools
+- `integration-testing` — Integration test tools
+- `coverage` — Code coverage tools
+- `linting` — Code linters
+- `formatting` — Code formatters
+- `benchmarking` — Performance benchmarking
+
+### Package Management
+- `package-manager` — Package/dependency managers
+- `npm` — NPM packages
+- `cargo` — Rust packages
+- `pip` — Python packages
+
+### Development Tools
+- `development` — General development tools
+- `debugging` — Debuggers and debugging tools
+- `documentation` — Documentation generators
+- `asm` — Assembly language tools
+
+## Category: DevOps & Infrastructure
+
+### Container & Orchestration
+- `docker` — Docker containers
+- `kubernetes` — Kubernetes orchestration
+- `container` — Container technologies
+- `orchestration` — Orchestration tools
+
+### Infrastructure & IaC
+- `devops` — DevOps tools and practices
+- `iac` — Infrastructure as Code
+- `terraform` — Terraform IaC
+- `cloud` — Cloud computing
+- `deployment` — Deployment tools
+- `ci-cd` — CI/CD pipelines
+
+### Cloud Providers
+- `aws` — Amazon Web Services
+- `azure` — Microsoft Azure
+- `gcp` — Google Cloud Platform
+- `linode` — Linode cloud
+- `digital-ocean` — DigitalOcean cloud
+- `vultr` — Vultr cloud
+- `scaleway` — Scaleway cloud
+
+### Monitoring & Logging
+- `monitoring` — Monitoring tools
+- `logging` — Logging tools
+- `observability` — Observability tools
+- `metrics` — Metrics collection
+
+## Category: Data & Database
+
+### Databases
+- `database` — Database tools
+- `sql` — SQL databases
+- `nosql` — NoSQL databases
+- `postgresql` — PostgreSQL
+- `mysql` — MySQL/MariaDB
+- `mongodb` — MongoDB
+- `redis` — Redis cache
+- `elasticsearch` — Elasticsearch
+
+### Data Processing
+- `data` — Data processing tools
+- `analytics` — Data analytics
+- `machine-learning` — ML/AI tools
+- `data-processing` — Data transformation
+
+## Category: Web & Networking
+
+### Web
+- `web` — Web technologies
+- `http` — HTTP tools
+- `api` — API tools
+- `rest` — REST APIs
+- `websocket` — WebSocket tools
+- `frontend` — Frontend development
+- `backend` — Backend development
+- `nodejs` — Node.js
+
+### Networking
+- `network` — Networking tools
+- `dns` — DNS tools
+- `vpn` — VPN tools
+- `proxy` — Proxy servers
+- `socket` — Socket programming
+
+## Category: Security
+
+- `security` — Security tools
+- `crypto` — Cryptography
+- `ssl` — SSL/TLS
+- `auth` — Authentication
+- `encryption` — Encryption tools
+- `password` — Password management
+- `vulnerability` — Vulnerability scanning
+
+## Category: Shell & Terminal
+
+### Shell Tools
+- `shell` — Shell tools and utilities
+- `bash` — Bash shell (also language)
+- `zsh` — Zsh shell
+- `fish` — Fish shell
+- `terminal` — Terminal utilities
+- `console` — Console tools
+- `prompt` — Shell prompts
+
+### Shell Utilities
+- `file-search` — File search tools
+- `text-processing` — Text processing
+- `system` — System utilities
+- `process` — Process management
+
+## Category: Utilities
+
+### System
+- `system` — System tools
+- `linux` — Linux-specific
+- `unix` — Unix-like systems
+- `macos` — macOS-specific
+- `windows` — Windows-specific
+- `os` — OS tools
+- `kernel` — Kernel-related
+
+### File & Directory
+- `filesystem` — File system tools
+- `file-search` — File searching
+- `file-management` — File operations
+- `directory` — Directory utilities
+- `compression` — Compression tools
+- `archive` — Archive tools
+
+### Productivity
+- `productivity` — Productivity tools
+- `task-management` — Task management
+- `note-taking` — Note taking
+- `project-management` — Project management
+- `time-tracking` — Time tracking
+
+### Media & Graphics
+- `media` — Media tools
+- `image` — Image processing
+- `video` — Video processing
+- `audio` — Audio processing
+- `graphics` — Graphics tools
+- `conversion` — File conversion
+
+## Category: CLI & Interface
+
+- `cli` — Command-line tools
+- `command-line` — Command-line utilities
+- `interactive` — Interactive tools
+- `filter` — Data filtering
+- `search` — Search tools
+- `fuzzy-search` — Fuzzy searching
+
+## Emerging Categories
+
+- `ai` — AI/ML tools
+- `llm` — Large Language Models
+- `blockchain` — Blockchain tools
+- `web3` — Web3 tools
+- `devtools` — Developer tools
+- `utility` — General utilities
+
+---
+
+## Guidelines for Using Tags
+
+1. **Always use 3-8 tags** per plugin
+2. **Use specific tags** over generic ones
+   - ✓ `rust`, `async`, `tokio`
+   - ✗ `development`, `tool`
+3. **Match tool primary purpose** first
+   - `ripgrep-all` → `search`, `rust`, `file-search`
+   - Not: `cli`, `utility`
+4. **Include language if relevant**
+   - `tokio` → `rust`, `async`, ...
+5. **Include domain if applicable**
+   - `terraform` → `devops`, `iac`, `cloud`, ...
+
+## Statistics
+
+- **Total tags:** 120+
+- **Most used:** `cli`, `utility`, `development`
+- **Categories:** 12 major categories
+- **New tags encouraged** as collection grows (propose in PR)

package/apply-description-enhancements.ts

@@ -0,0 +1,69 @@
+#!/usr/bin/env bun
+import { readFileSync, writeFileSync } from "fs";
+
+interface Enhancement {
+  name: string;
+  current: string;
+  suggested: string;
+  confidence: number;
+}
+
+// Confidence threshold for auto-apply
+const AUTO_APPLY_THRESHOLD = 85;
+
+async function main() {
+  console.log("✨ Applying Description Enhancements");
+  console.log("===================================\n");
+
+  // Load data
+  const plugins = JSON.parse(readFileSync("marketing/plugins-dump.json", "utf-8"));
+  const enhancements: Enhancement[] = JSON.parse(readFileSync("description-enhancements.json", "utf-8"));
+
+  // Separate by confidence
+  const highConf = enhancements.filter((e) => e.confidence >= AUTO_APPLY_THRESHOLD);
+  const mediumConf = enhancements.filter((e) => e.confidence < AUTO_APPLY_THRESHOLD);
+
+  console.log(`High-confidence (>= ${AUTO_APPLY_THRESHOLD}): ${highConf.length}`);
+  console.log(`Medium-confidence (< ${AUTO_APPLY_THRESHOLD}): ${mediumConf.length}\n`);
+
+  // Create map for fast lookup
+  const pluginMap = new Map(plugins.map((p) => [p.name, p]));
+
+  // Apply high-confidence enhancements
+  console.log(`📝 Applying ${highConf.length} high-confidence enhancements...\n`);
+
+  let applied = 0;
+  for (const enhancement of highConf) {
+    const plugin = pluginMap.get(enhancement.name);
+    if (plugin && plugin.description === enhancement.current) {
+      plugin.description = enhancement.suggested;
+      applied++;
+      console.log(`✓ ${enhancement.name}`);
+    }
+  }
+
+  console.log(`\n✅ Applied: ${applied} high-confidence enhancements`);
+
+  // Show medium-confidence for review
+  if (mediumConf.length > 0) {
+    console.log(`\n⚠️  ${mediumConf.length} medium-confidence suggestions (manual review recommended):`);
+    mediumConf.forEach((e) => {
+      console.log(`\n  ${e.name} (confidence: ${e.confidence}%)`);
+      console.log(`    → "${e.suggested}"`);
+    });
+  }
+
+  // Save updated plugins
+  writeFileSync("marketing/plugins-dump.json", JSON.stringify(pluginMap.get(...pluginMap.keys()) ? plugins : plugins, null, 2));
+
+  // Re-check quality
+  const afterShort = plugins.filter((p) => (p.description || "").length < 30);
+  console.log(`\n📊 Quality After Enhancement`);
+  console.log(`===========================`);
+  console.log(`Short descriptions remaining: ${afterShort.length}`);
+  console.log(`Average description length: ${Math.round(plugins.reduce((sum, p) => sum + (p.description || "").length, 0) / plugins.length)} chars`);
+
+  console.log(`\n✓ plugins-dump.json updated`);
+}
+
+main().catch(console.error);

package/apply-plugin-fixes.ts

@@ -0,0 +1,83 @@
+#!/usr/bin/env bun
+import { readFileSync, writeFileSync } from "fs";
+
+interface Plugin {
+  name: string;
+  description: string;
+  tags: string[];
+  source: string;
+  installSteps: string[];
+}
+
+interface Suggestion {
+  name: string;
+  issues: string[];
+  suggestions: {
+    sourceUrl?: string;
+    additionalTags?: string[];
+    descriptionTip?: string;
+  };
+}
+
+interface Report {
+  suggestions: Suggestion[];
+}
+
+async function main() {
+  console.log("🔧 Applying Plugin Quality Fixes");
+  console.log("================================\n");
+
+  // Load suggestions and plugins
+  const report: Report = JSON.parse(readFileSync("plugin-quality-report.json", "utf-8"));
+  const plugins: Plugin[] = JSON.parse(readFileSync("marketing/plugins-dump.json", "utf-8"));
+
+  const pluginMap = new Map(plugins.map(p => [p.name, p]));
+  let fixed = 0;
+  let sourceUrlsAdded = 0;
+  let tagsAdded = 0;
+
+  for (const suggestion of report.suggestions) {
+    const plugin = pluginMap.get(suggestion.name);
+    if (!plugin) continue;
+
+    // Apply source URL fix
+    if (suggestion.suggestions.sourceUrl && (!plugin.source || plugin.source === "https://github.com")) {
+      plugin.source = suggestion.suggestions.sourceUrl;
+      sourceUrlsAdded++;
+      console.log(`✓ ${plugin.name}: Source URL added`);
+    }
+
+    // Apply tag suggestions
+    if (suggestion.suggestions.additionalTags) {
+      const before = plugin.tags.length;
+      suggestion.suggestions.additionalTags.forEach(tag => {
+        if (!plugin.tags.includes(tag)) {
+          plugin.tags.push(tag);
+        }
+      });
+      if (plugin.tags.length > before) {
+        tagsAdded += plugin.tags.length - before;
+        console.log(`✓ ${plugin.name}: Added ${plugin.tags.length - before} tags`);
+      }
+    }
+
+    fixed++;
+  }
+
+  // Re-sort plugin array
+  const updatedPlugins = Array.from(pluginMap.values()).sort((a, b) =>
+    a.name.localeCompare(b.name)
+  );
+
+  // Save updated dump
+  writeFileSync("marketing/plugins-dump.json", JSON.stringify(updatedPlugins, null, 2));
+
+  console.log(`\n✅ Quality Fixes Applied`);
+  console.log(`========================`);
+  console.log(`Plugins fixed: ${fixed}`);
+  console.log(`Source URLs added: ${sourceUrlsAdded}`);
+  console.log(`Tags added: ${tagsAdded}`);
+  console.log(`\n✓ Updated plugins-dump.json with ${updatedPlugins.length} plugins`);
+}
+
+main().catch(console.error);

package/batch-enhance-descriptions.ts

@@ -0,0 +1,222 @@
+#!/usr/bin/env bun
+import { readFileSync, writeFileSync } from "fs";
+
+interface Plugin {
+  name: string;
+  description: string;
+  tags: string[];
+  source: string;
+  installSteps: string[];
+}
+
+interface Enhancement {
+  name: string;
+  current: string;
+  suggested: string;
+  confidence: number;
+}
+
+// Comprehensive description knowledge base
+const DESCRIPTIONS: Record<string, string> = {
+  // Shells
+  "bash": "GNU Bash — portable shell interpreter with scripting capabilities",
+  "zsh": "Zsh — advanced shell with interactive features and scripting",
+  "fish": "Fish shell — user-friendly shell with intuitive syntax",
+  "ksh": "Korn Shell — POSIX shell with C-like syntax",
+  "tcsh": "Tcsh — C shell with command-line editing and history",
+  "mksh": "mksh — lightweight POSIX shell implementation",
+  "xonsh": "Xonsh — Python-powered shell blending shell and Python",
+  "nushell": "Nushell — structured shell language for modern development",
+
+  // Version Control & Development
+  "git-cliff": "git-cliff — automated changelog generator from git history",
+  "git": "Git — distributed version control system for code",
+  "gh": "GitHub CLI — command-line interface for GitHub operations",
+
+  // Search & Navigation
+  "ripgrep-all": "ripgrep-all — search documents with ripgrep backend",
+  "rg-all": "ripgrep-all variant — enhanced search across file types",
+  "zoxide": "Zoxide — smart directory jumper with frecency tracking",
+  "fzf": "fzf — command-line fuzzy finder for interactive filtering",
+
+  // Terminal Tools
+  "tldr": "tldr — simplified man pages with practical examples",
+  "hyperfine": "Hyperfine — command benchmarking tool for performance testing",
+  "watchexec": "Watchexec — runs commands on file system changes",
+  "peco": "Peco — simple interactive filter for shell piping",
+  "sk": "Skim — fuzzy finder written in Rust for speed",
+
+  // Package Managers & Build
+  "cargo": "Cargo — Rust package manager and build system",
+  "npm": "npm — Node.js package manager for JavaScript",
+  "pnpm": "pnpm — fast npm alternative with disk efficiency",
+  "poetry": "Poetry — Python dependency management and packaging",
+  "cargo-watch": "cargo-watch — watches files and rebuilds on changes",
+  "cargo-tree": "cargo-tree — displays dependency tree for Rust projects",
+  "wasm-pack": "wasm-pack — tool for building Rust WebAssembly projects",
+
+  // Data & Serialization
+  "serde": "Serde — serialization framework for Rust",
+  "toml": "TOML — configuration file format parser",
+  "yaml": "YAML — human-friendly data serialization format",
+  "serde-json": "serde-json — JSON serialization for Rust",
+  "ron": "RON — Rusty Object Notation serialization format",
+
+  // Testing & Quality
+  "proptest": "proptest — property-based testing framework for Rust",
+  "quickcheck": "quickcheck — property-based testing for Rust",
+  "criterion": "criterion — benchmarking library for Rust",
+  "nextest": "nextest — next-generation test runner for Rust",
+
+  // Async & Concurrency
+  "tokio": "Tokio — async runtime for Rust applications",
+  "async-std": "async-std — async/await for Rust",
+
+  // Parsing & Language Tools
+  "tree-sitter": "Tree-sitter — incremental parsing system for programming languages",
+  "lalrpop": "LALRPOP — LR parser generator for Rust",
+  "nom": "nom — parser combinator library for Rust",
+  "nom-derive": "nom-derive — derive macros for nom parsers",
+
+  // Web & Networking
+  "surf": "Surf — async HTTP client library for Rust",
+  "httpie": "HTTPie — user-friendly HTTP client for command line",
+
+  // Cloud & Infrastructure
+  "nomad": "Nomad — workload orchestrator across datacenters",
+  "docker": "Docker — containerization platform for application deployment",
+  "kubernetes": "Kubernetes — container orchestration for scalable deployments",
+  "libp2p": "libp2p — peer-to-peer networking library",
+
+  // CLI Tools
+  "structopt": "structopt — derive macros for CLI argument parsing",
+  "pico-args": "pico-args — minimal argument parser for Rust",
+  "getopts": "getopts — command-line argument parsing library",
+
+  // Utilities
+  "tree-climb": "tree-climb — recursively search directory tree",
+  "tree-query": "tree-query — query tree structures",
+  "tree-walk": "tree-walk — traverse directory trees",
+  "num-format": "num-format — format numbers with separators",
+  "pickle": "pickle — serialization format",
+  "rand": "rand — Rust random number generator library",
+  "html-minifier": "html-minifier — HTML compression and minification",
+
+  // Cloud Providers
+  "linode-cli": "Linode CLI — command-line tool for Linode cloud",
+  "vultr-cli": "Vultr CLI — command-line interface for Vultr cloud",
+  "scaleway": "Scaleway CLI — command-line tool for Scaleway cloud",
+  "googlews": "Google Workspace CLI — manage Google Workspace services",
+  "hostvn": "HostVN CLI — Vietnam hosting provider interface",
+
+  // Web Frameworks
+  "yew": "Yew — Rust framework for building web frontends",
+  "trunk": "Trunk — build system for Rust web applications",
+
+  // Specialized
+  "openpilot": "OpenPilot — open-source autonomous driving system",
+  "massgen": "Massgen — multi-agent system coordination tool",
+  "matchmaker": "Matchmaker — pattern matching utility",
+  "graphify-out": "Graphify output — knowledge graph utilities",
+};
+
+function enhanceDescription(plugin: Plugin): Enhancement {
+  const { name, description, tags } = plugin;
+
+  // Try direct lookup first
+  if (DESCRIPTIONS[name]) {
+    return {
+      name,
+      current: description,
+      suggested: DESCRIPTIONS[name],
+      confidence: 95,
+    };
+  }
+
+  // Try lowercase match
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(DESCRIPTIONS)) {
+    if (key.toLowerCase() === lowerName) {
+      return {
+        name,
+        current: description,
+        suggested: value,
+        confidence: 90,
+      };
+    }
+  }
+
+  // Try partial match in tags
+  for (const tag of tags) {
+    if (DESCRIPTIONS[tag]) {
+      const suggestion = `${name} — ${tag} tool`;
+      return {
+        name,
+        current: description,
+        suggested: suggestion,
+        confidence: 60,
+      };
+    }
+  }
+
+  // Fallback: construct from tags
+  if (tags.length >= 2) {
+    const suggestion = `${name} — ${tags[0]} tool for ${tags[1]}`;
+    return {
+      name,
+      current: description,
+      suggested: suggestion,
+      confidence: 40,
+    };
+  }
+
+  return {
+    name,
+    current: description,
+    suggested: `${name} — command-line utility`,
+    confidence: 30,
+  };
+}
+
+async function main() {
+  console.log("🔧 Batch Description Enhancement");
+  console.log("================================\n");
+
+  // Load plugins
+  const plugins: Plugin[] = JSON.parse(readFileSync("marketing/plugins-dump.json", "utf-8"));
+  const shortDesc = plugins.filter((p) => (p.description || "").length < 30);
+
+  console.log(`Processing ${shortDesc.length} plugins with short descriptions\n`);
+
+  // Generate suggestions
+  const enhancements = shortDesc.map((p) => enhanceDescription(p));
+
+  // Sort by confidence
+  enhancements.sort((a, b) => b.confidence - a.confidence);
+
+  // Display high-confidence suggestions
+  console.log("🎯 High-Confidence Suggestions (Confidence >= 85):\n");
+  const highConf = enhancements.filter((e) => e.confidence >= 85);
+  highConf.slice(0, 20).forEach((e) => {
+    console.log(`${e.name}`);
+    console.log(`  Current: "${e.current}"`);
+    console.log(`  → "${e.suggested}"`);
+    console.log();
+  });
+
+  console.log(`\n📊 Confidence Distribution:`);
+  console.log(`  >= 85: ${enhancements.filter((e) => e.confidence >= 85).length}`);
+  console.log(`  70-84: ${enhancements.filter((e) => e.confidence >= 70 && e.confidence < 85).length}`);
+  console.log(`  50-69: ${enhancements.filter((e) => e.confidence >= 50 && e.confidence < 70).length}`);
+  console.log(`  < 50:  ${enhancements.filter((e) => e.confidence < 50).length}`);
+
+  // Save report
+  writeFileSync("description-enhancements.json", JSON.stringify(enhancements, null, 2));
+  console.log("\n✓ Full report saved to: description-enhancements.json");
+
+  // Ask for auto-apply
+  console.log("\n💡 Suggestion: Review description-enhancements.json to see all suggestions");
+  console.log("   Then run: bun apply-description-enhancements.ts");
+}
+
+main().catch(console.error);