superacli 1.1.6 → 1.1.8

package/plugins/clever/skills/resource-inventory.md

@@ -0,0 +1,24 @@
+# Clever Resource Inventory Skill
+
+Use this skill to inventory Clever Cloud resources through JSON-first wrappers.
+
+## Recommended Sequence
+
+```bash
+dcli clever auth whoami
+dcli clever apps list
+dcli clever addons list
+dcli clever tokens list
+```
+
+## Why This Sequence
+
+- confirms auth before querying account resources
+- collects app and add-on state for deployment planning
+- inventories API bridge tokens for integration visibility
+
+## Agent Notes
+
+- Keep responses as structured objects; avoid parsing human-formatted output.
+- Treat missing auth as a hard precondition failure.
+- Use passthrough only for commands not yet wrapped by the plugin.

package/plugins/clix/README.md

@@ -1,12 +1,12 @@
 # clix Plugin Harness
 
-This plugin is a hybrid harness for `clix`: it indexes the upstream `SKILL.md` and `README.md` into the local skills catalog and exposes a curated set of safe read-only wrappers.
+This plugin is a hybrid harness for `clix`: it indexes the upstream `SKILL.md` and `README.md` into the local skill-doc catalog and exposes a curated set of safe read-only wrappers.
 
 ## Why This Scope
 
 `clix` can post, delete, like, retweet, and mutate bookmarks using cookie-based auth. The wrapped commands in this plugin intentionally focus on low-risk read-only workflows.
 
-- upstream agent docs are indexed into the skills catalog
+- upstream agent docs are indexed into the skill-doc catalog
 - read-only wrappers are exposed for auth status, timelines, search, tweets, users, and bookmarks
 - no wildcard passthrough in v1
 - no auth mutation, posting, delete, like, retweet, or bookmark mutation wrappers
@@ -17,7 +17,7 @@ This plugin is a hybrid harness for `clix`: it indexes the upstream `SKILL.md` a
 supercli plugins install clix --json
 ```
 
-## Explore Indexed Skills
+## Explore Indexed Skill Documents
 
 ```bash
 supercli skills list --catalog --provider clix --json
@@ -41,4 +41,4 @@ supercli clix bookmarks list --json
 - Wrapped commands always request upstream `--json` output and return parsed data in the dcli envelope.
 - `clix` uses cookie-based auth and may access local browser/session data. Treat that auth state as sensitive.
 - Use upstream `clix` directly for login, account switching, posting, deleting, likes, retweets, and bookmark mutations.
-- Removing the plugin also removes its registered skills provider from the local catalog.
+- Removing the plugin also removes its registered skill-doc provider from the local catalog.

package/plugins/cocoindex-code/README.md

@@ -0,0 +1,64 @@
+# cocoindex-code Plugin Harness
+
+This plugin integrates `cocoindex-code` into supercli with automatic local MCP server registration, a fast direct search capability for day-to-day use, and an MCP-backed search capability for MCP-native workflows.
+
+## What You Get
+
+- auto-registers local MCP server `cocoindex-code`
+- fast capability: `supercli cocoindex code search`
+- MCP capability: `supercli cocoindex mcp search`
+- helper capability: `supercli cocoindex index build`
+- learn content via `supercli plugins learn cocoindex-code`
+
+## Prerequisites
+
+Install `cocoindex-code` first (choose one):
+
+```bash
+pipx install cocoindex-code
+# or
+uv tool install --upgrade cocoindex-code --prerelease explicit --with "cocoindex>=1.0.0a24"
+```
+
+Verify binary availability:
+
+```bash
+cocoindex-code --help
+```
+
+## Install Plugin
+
+```bash
+supercli plugins learn cocoindex-code
+supercli plugins install cocoindex-code --json
+```
+
+## Wrapped Capabilities
+
+```bash
+# Build/refresh index first (recommended for large repos)
+supercli cocoindex index build --json
+
+# Preferred for humans and bots: fast semantic code search
+supercli cocoindex code search --query "where is auth middleware implemented" --limit 5 --json
+supercli cocoindex code search --query "session handling" --offset 5 --json
+supercli cocoindex code search --query "entrypoint reads process.argv rawArgs and parses flags" --paths "cli/*" --limit 5 --json
+
+# Optional MCP-native search
+supercli cocoindex mcp search --query "where is auth middleware implemented" --limit 5 --json
+```
+
+## Notes
+
+- Prefer `cocoindex code search` for both humans and non-human agents. It is the fastest, easiest path and searches the current repo directly.
+- `cocoindex code search` uses a direct wrapper around the installed `cocoindex-code` Python package, so it avoids per-query MCP server startup overhead.
+- `cocoindex mcp search` maps to MCP tool `search` on server `cocoindex-code`.
+- Use `cocoindex mcp search` only when you specifically need an MCP-shaped workflow.
+- For advanced MCP input fields such as `languages` or `paths`, use direct MCP call:
+
+```bash
+supercli mcp call --mcp-server cocoindex-code --tool search --input-json '{"query":"auth","languages":["python"],"paths":["src/*"],"limit":5}' --timeout-ms 180000 --json
+```
+
+- By default, cocoindex-code auto-discovers root from `.cocoindex_code/`, `.git/`, or current directory.
+- Optional env vars: `COCOINDEX_CODE_ROOT_PATH`, `COCOINDEX_CODE_EMBEDDING_MODEL`, `COCOINDEX_CODE_EXCLUDED_PATTERNS`.

package/plugins/cocoindex-code/plugin.json

@@ -0,0 +1,81 @@
+{
+  "name": "cocoindex-code",
+  "version": "0.1.0",
+  "description": "Hybrid cocoindex-code plugin: auto-register local MCP server, bind semantic search capability, and add quickstart skill docs",
+  "source": "https://github.com/cocoindex-io/cocoindex-code",
+  "checks": [
+    { "type": "binary", "name": "cocoindex-code" }
+  ],
+  "learn": {
+    "file": "skills/quickstart/SKILL.md"
+  },
+  "post_install": {
+    "script": "scripts/post-install.js",
+    "runtime": "node",
+    "timeout_ms": 15000
+  },
+  "post_uninstall": {
+    "script": "scripts/post-uninstall.js",
+    "runtime": "node",
+    "timeout_ms": 15000
+  },
+  "commands": [
+    {
+      "namespace": "cocoindex",
+      "resource": "code",
+      "action": "search",
+      "description": "Semantic code search via direct cocoindex-code query wrapper",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "node",
+        "baseArgs": ["scripts/run-query.js"],
+        "parseJson": true,
+        "timeout_ms": 180000,
+        "missingDependencyHelp": "Install with: uv tool install --upgrade cocoindex-code --prerelease explicit --with \"cocoindex>=1.0.0a24\""
+      },
+      "args": [
+        { "name": "query", "type": "string", "required": true, "description": "Natural language query or code snippet" },
+        { "name": "limit", "type": "integer", "required": false, "description": "Maximum results to return" },
+        { "name": "offset", "type": "integer", "required": false, "description": "Pagination offset" },
+        { "name": "languages", "type": "string", "required": false, "description": "Comma-separated language filters" },
+        { "name": "paths", "type": "string", "required": false, "description": "Comma-separated glob path filters" },
+        { "name": "root", "type": "string", "required": false, "description": "Repository root path override" },
+        { "name": "refresh-index", "type": "boolean", "required": false, "description": "Refresh index before search" }
+      ]
+    },
+    {
+      "namespace": "cocoindex",
+      "resource": "mcp",
+      "action": "search",
+      "description": "Semantic code search via cocoindex-code MCP server",
+      "adapter": "mcp",
+      "adapterConfig": {
+        "server": "cocoindex-code",
+        "tool": "search",
+        "mcp_protocol": "jsonrpc",
+        "timeout_ms": 180000
+      },
+      "args": [
+        { "name": "query", "type": "string", "required": true, "description": "Natural language query or code snippet" },
+        { "name": "limit", "type": "integer", "required": false, "description": "Maximum results to return" },
+        { "name": "offset", "type": "integer", "required": false, "description": "Pagination offset" },
+        { "name": "refresh_index", "type": "boolean", "required": false, "description": "Refresh index before search" }
+      ]
+    },
+    {
+      "namespace": "cocoindex",
+      "resource": "index",
+      "action": "build",
+      "description": "Build or refresh cocoindex-code local index",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "cocoindex-code",
+        "baseArgs": ["index"],
+        "parseJson": false,
+        "timeout_ms": 180000,
+        "missingDependencyHelp": "Install with: pipx install cocoindex-code"
+      },
+      "args": []
+    }
+  ]
+}

package/plugins/cocoindex-code/scripts/post-install.js

@@ -0,0 +1,61 @@
+const path = require("path")
+const { addProvider, syncCatalog } = require("../../../cli/skills-catalog")
+const { setMcpServer, listMcpServers } = require("../../../cli/config")
+
+const PLUGIN_NAME = "cocoindex-code"
+const MCP_SERVER_NAME = "cocoindex-code"
+const SKILLS_ROOT = path.resolve(__dirname, "..", "skills")
+
+const DEFAULT_SERVER = {
+  command: "cocoindex-code",
+  args: [],
+  timeout_ms: 180000,
+}
+
+async function ensureMcpServer() {
+  const servers = await listMcpServers()
+  const existing = (servers || []).find((s) => s && s.name === MCP_SERVER_NAME)
+  if (existing) return { server: existing, created: false }
+  await setMcpServer(MCP_SERVER_NAME, DEFAULT_SERVER)
+  return {
+    server: { name: MCP_SERVER_NAME, ...DEFAULT_SERVER },
+    created: true,
+  }
+}
+
+async function run() {
+  const { created } = await ensureMcpServer()
+
+  addProvider({
+    name: PLUGIN_NAME,
+    type: "local_fs",
+    roots: [SKILLS_ROOT],
+    enabled: true,
+  })
+
+  const index = syncCatalog()
+  return {
+    plugin: PLUGIN_NAME,
+    mcp_server: MCP_SERVER_NAME,
+    server_created: created,
+    bound_capabilities: ["cocoindex.code.search", "cocoindex.mcp.search", "cocoindex.index.build"],
+    provider: PLUGIN_NAME,
+    synced_skills: Array.isArray(index.skills) ? index.skills.length : 0,
+  }
+}
+
+if (require.main === module) {
+  run()
+    .then((result) => {
+      process.stdout.write(JSON.stringify(result))
+    })
+    .catch((err) => {
+      process.stderr.write(err.message)
+      process.exit(1)
+    })
+}
+
+module.exports = {
+  run,
+  DEFAULT_SERVER,
+}

package/plugins/cocoindex-code/scripts/post-uninstall.js

@@ -0,0 +1,25 @@
+const { removeProvider, syncCatalog } = require("../../../cli/skills-catalog")
+
+async function run() {
+  const removedProvider = removeProvider("cocoindex-code")
+  const index = syncCatalog()
+  return {
+    plugin: "cocoindex-code",
+    removed_provider: removedProvider,
+    synced_skills: Array.isArray(index.skills) ? index.skills.length : 0,
+    note: "MCP server 'cocoindex-code' was not removed automatically. Run: supercli mcp remove cocoindex-code",
+  }
+}
+
+if (require.main === module) {
+  run()
+    .then((result) => {
+      process.stdout.write(JSON.stringify(result))
+    })
+    .catch((err) => {
+      process.stderr.write(err.message)
+      process.exit(1)
+    })
+}
+
+module.exports = { run }

package/plugins/cocoindex-code/scripts/query.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+import argparse
+import asyncio
+import json
+import os
+import sys
+
+
+def parse_csv_list(value):
+    if not value:
+        return None
+    items = [item.strip() for item in value.split(",") if item.strip()]
+    return items or None
+
+
+async def main_async(args):
+    root = os.path.abspath(
+        args.root or os.environ.get("SUPERCLI_INVOKE_CWD") or os.getcwd()
+    )
+    os.environ["COCOINDEX_CODE_ROOT_PATH"] = root
+
+    from cocoindex_code.indexer import app as indexer_app
+    from cocoindex_code.query import query_codebase
+
+    if args.refresh_index:
+        await indexer_app.update(report_to_stdout=False)
+
+    results = await query_codebase(
+        query=args.query,
+        limit=args.limit,
+        offset=args.offset,
+        languages=parse_csv_list(args.languages),
+        paths=parse_csv_list(args.paths),
+    )
+
+    payload = {
+        "success": True,
+        "root": root,
+        "query": args.query,
+        "total_returned": len(results),
+        "offset": args.offset,
+        "results": [
+            {
+                "file_path": item.file_path,
+                "language": item.language,
+                "content": item.content,
+                "start_line": item.start_line,
+                "end_line": item.end_line,
+                "score": item.score,
+            }
+            for item in results
+        ],
+    }
+    print(json.dumps(payload))
+
+
+def build_parser():
+    parser = argparse.ArgumentParser(description="Query cocoindex-code directly")
+    parser.add_argument("--query", required=True)
+    parser.add_argument("--limit", type=int, default=5)
+    parser.add_argument("--offset", type=int, default=0)
+    parser.add_argument("--root")
+    parser.add_argument("--languages")
+    parser.add_argument("--paths")
+    parser.add_argument("--refresh-index", action="store_true")
+    return parser
+
+
+def main():
+    parser = build_parser()
+    args = parser.parse_args()
+    try:
+        asyncio.run(main_async(args))
+    except Exception as err:
+        print(
+            json.dumps(
+                {
+                    "success": False,
+                    "message": str(err),
+                }
+            )
+        )
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/plugins/cocoindex-code/scripts/run-query.js

@@ -0,0 +1,50 @@
+const fs = require("fs")
+const path = require("path")
+const { spawnSync } = require("child_process")
+
+function resolvePythonFromLauncher() {
+  const which = spawnSync("which", ["cocoindex-code"], { encoding: "utf-8", timeout: 3000 })
+  if (which.error || which.status !== 0) {
+    throw new Error("Could not locate 'cocoindex-code' in PATH")
+  }
+
+  const launcher = (which.stdout || "").trim()
+  const firstLine = fs.readFileSync(launcher, "utf-8").split("\n", 1)[0] || ""
+  if (!firstLine.startsWith("#!")) {
+    throw new Error("Could not resolve cocoindex-code Python interpreter from launcher")
+  }
+
+  return firstLine.slice(2).trim()
+}
+
+function run() {
+  const python = resolvePythonFromLauncher()
+  const script = path.resolve(__dirname, "query.py")
+  const args = process.argv.slice(2)
+  const result = spawnSync(python, [script, ...args], {
+    encoding: "utf-8",
+    timeout: 300000,
+    env: process.env,
+  })
+
+  if (result.error) {
+    throw result.error
+  }
+
+  if (result.stdout) process.stdout.write(result.stdout)
+  if (result.status !== 0) {
+    if (result.stderr) process.stderr.write(result.stderr)
+    process.exit(result.status || 1)
+  }
+}
+
+if (require.main === module) {
+  try {
+    run()
+  } catch (err) {
+    process.stderr.write(err.message)
+    process.exit(1)
+  }
+}
+
+module.exports = { run, resolvePythonFromLauncher }

package/plugins/cocoindex-code/skills/quickstart/SKILL.md

@@ -0,0 +1,73 @@
+---
+skill_name: cocoindex-code.quickstart
+description: Install cocoindex-code, auto-register MCP via supercli plugin install, then prefer the fast direct search capability for repository search; keep MCP search for MCP-native flows.
+tags: cocoindex,mcp,semantic-search,code,agents
+---
+
+# cocoindex-code Quickstart
+
+Use this when you need semantic code search over a repository via SuperCLI.
+
+Prefer `supercli cocoindex code search` for normal bot and human usage. It is the easiest and fastest path.
+
+## 1) Install upstream binary
+
+```bash
+pipx install cocoindex-code
+# or
+uv tool install --upgrade cocoindex-code --prerelease explicit --with "cocoindex>=1.0.0a24"
+```
+
+## 2) Install plugin (auto MCP registration)
+
+```bash
+supercli plugins learn cocoindex-code
+supercli plugins install cocoindex-code --json
+```
+
+This creates MCP server `cocoindex-code` (if missing) and binds capabilities `cocoindex.code.search` and `cocoindex.mcp.search`.
+
+## 3) Build index once (recommended)
+
+```bash
+supercli cocoindex index build --json
+```
+
+For small repos this is optional; indexing can happen on first search.
+
+## 4) Preferred search flow (humans and bots)
+
+```bash
+supercli cocoindex code search --query "how are sessions stored" --limit 5 --json
+supercli cocoindex code search --query "error handling middleware" --offset 5 --json
+supercli cocoindex code search --query "entrypoint reads process.argv rawArgs and parses flags" --paths "cli/*" --limit 5 --json
+```
+
+`cocoindex code search` runs directly against the installed `cocoindex-code` package, so it avoids MCP server startup overhead and targets the current repo by default.
+
+## 5) MCP-native search (optional)
+
+```bash
+supercli cocoindex mcp search --query "how are sessions stored" --limit 5 --json
+```
+
+Use this only when you explicitly need MCP-native execution.
+
+## 6) Advanced search with language/path filters
+
+```bash
+supercli mcp call --mcp-server cocoindex-code --tool search --input-json '{"query":"database connection","languages":["typescript"],"paths":["src/*"],"limit":10}' --timeout-ms 180000 --json
+```
+
+## Optional Configuration
+
+```bash
+export COCOINDEX_CODE_ROOT_PATH=/path/to/repo
+export COCOINDEX_CODE_EMBEDDING_MODEL=sbert/nomic-ai/CodeRankEmbed
+```
+
+`COCOINDEX_CODE_EXCLUDED_PATTERNS` expects a JSON array string, for example:
+
+```bash
+export COCOINDEX_CODE_EXCLUDED_PATTERNS='["**/generated/**","**/*.snap"]'
+```

package/plugins/copilot/README.md

@@ -0,0 +1,24 @@
+# Copilot Plugin
+
+`copilot` wraps GitHub Copilot CLI for scriptable, non-interactive workflows in supercli.
+
+## Install
+
+```bash
+supercli plugins install copilot --json
+npm install -g @github/copilot
+```
+
+## Commands
+
+- `supercli copilot cli version`
+- `supercli copilot task ask --prompt "..."`
+- `supercli copilot task ask-json --prompt "..."`
+- `supercli copilot <any upstream args...>`
+
+## Notes
+
+- `task ask` runs prompt mode with default Copilot output.
+- `task ask-json` is a compatibility alias that currently runs non-stream text mode (`--stream off`) because the installed CLI build does not expose JSON output flags.
+- Login and plan entitlements are required before automation (`copilot login`).
+- Wrapper commands do not force permissive tool flags; use passthrough for advanced autonomy controls.

package/plugins/copilot/plugin.json

@@ -0,0 +1,80 @@
+{
+  "name": "copilot",
+  "version": "0.1.0",
+  "description": "GitHub Copilot CLI plugin with programmatic wrappers and passthrough",
+  "source": "https://docs.github.com/copilot/how-tos/copilot-cli/cli-getting-started",
+  "checks": [
+    { "type": "binary", "name": "copilot" }
+  ],
+  "learn": {
+    "file": "skills/quickstart/SKILL.md"
+  },
+  "commands": [
+    {
+      "namespace": "copilot",
+      "resource": "cli",
+      "action": "version",
+      "description": "Show installed Copilot CLI version",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "copilot",
+        "baseArgs": ["--version"],
+        "parseJson": false,
+        "missingDependencyHelp": "Install with: npm install -g @github/copilot"
+      },
+      "args": []
+    },
+    {
+      "namespace": "copilot",
+      "resource": "task",
+      "action": "ask",
+      "description": "Run a programmatic Copilot prompt and return text-only response",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "copilot",
+        "baseArgs": [],
+        "parseJson": false,
+        "timeout_ms": 180000,
+        "missingDependencyHelp": "Install with: npm install -g @github/copilot"
+      },
+      "args": [
+        { "name": "prompt", "type": "string", "required": true, "description": "Prompt to run in programmatic mode" },
+        { "name": "model", "type": "string", "required": false, "description": "Model id (optional)" }
+      ]
+    },
+    {
+      "namespace": "copilot",
+      "resource": "task",
+      "action": "ask-json",
+      "description": "Run a programmatic Copilot prompt with non-stream text output",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "copilot",
+        "baseArgs": ["--stream", "off"],
+        "parseJson": false,
+        "timeout_ms": 180000,
+        "missingDependencyHelp": "Install with: npm install -g @github/copilot"
+      },
+      "args": [
+        { "name": "prompt", "type": "string", "required": true, "description": "Prompt to run in programmatic mode" },
+        { "name": "model", "type": "string", "required": false, "description": "Model id (optional)" },
+        { "name": "agent", "type": "string", "required": false, "description": "Custom agent to use" }
+      ]
+    },
+    {
+      "namespace": "copilot",
+      "resource": "_",
+      "action": "_",
+      "description": "Passthrough command to execute any Copilot CLI command",
+      "adapter": "process",
+      "adapterConfig": {
+        "command": "copilot",
+        "passthrough": true,
+        "parseJson": true,
+        "timeout_ms": 180000,
+        "missingDependencyHelp": "Install with: npm install -g @github/copilot"
+      },
+      "args": []
+    }
+  ]
+}

package/plugins/copilot/skills/quickstart/SKILL.md

@@ -0,0 +1,44 @@
+---
+skill_name: copilot.quickstart
+description: Agent workflow for running GitHub Copilot CLI in non-interactive programmatic mode.
+tags: copilot,github,ai,automation,headless
+---
+
+# copilot Quickstart
+
+Use this when you need GitHub Copilot CLI for scripted prompts and machine-readable outputs.
+
+## 1) Install plugin and dependency
+
+```bash
+supercli plugins learn copilot
+supercli plugins install copilot --json
+npm install -g @github/copilot
+```
+
+## 2) Login and validate setup
+
+```bash
+copilot login
+supercli copilot cli version
+```
+
+## 3) Programmatic usage
+
+```bash
+supercli copilot task ask --prompt "Summarize the current branch changes"
+supercli copilot task ask-json --prompt "List top risks in this PR"
+```
+
+## 4) Full passthrough for advanced flags
+
+```bash
+supercli copilot -p "Explain this module" --output-format json
+supercli copilot -p "Draft a migration plan" --agent my-agent --output-format json
+```
+
+## 5) Caveats
+
+- Current Copilot CLI build in this environment does not expose JSON output flags; `task ask-json` runs in non-stream text mode (`--stream off`).
+- Copilot may require repository trust and auth setup on first run.
+- Keep tool permissions explicit for automation; use passthrough to set advanced `--allow-*` options when needed.

package/plugins/gemini/README.md

@@ -0,0 +1,24 @@
+# Gemini Plugin
+
+`gemini` wraps the Gemini CLI for agent-safe, non-interactive usage in supercli.
+
+## Install
+
+```bash
+supercli plugins install gemini --json
+npm install -g @google/gemini-cli
+```
+
+## Commands
+
+- `supercli gemini cli version`
+- `supercli gemini task text --prompt "..."`
+- `supercli gemini task ask --prompt "..."`
+- `supercli gemini task stream --prompt "..."`
+- `supercli gemini <any upstream args...>`
+
+## Notes
+
+- `task ask` uses `--output-format json`.
+- `task stream` uses `--output-format stream-json` and emits JSONL events.
+- For unattended automation, prefer API-key auth (`GEMINI_API_KEY`) instead of interactive login.