superacli 1.0.0

package/examples/mcp-sse/server.js

@@ -0,0 +1,81 @@
+#!/usr/bin/env node
+
+const http = require("http")
+
+const PORT = Number(process.env.MCP_SSE_PORT || 8787)
+const clients = new Set()
+
+function summarize(text) {
+  const normalized = String(text || "").trim().replace(/\s+/g, " ")
+  if (!normalized) return ""
+  const words = normalized.split(" ")
+  if (words.length <= 12) return normalized
+  return words.slice(0, 12).join(" ") + " ..."
+}
+
+function broadcast(event, data) {
+  const payload = `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`
+  for (const res of clients) {
+    res.write(payload)
+  }
+}
+
+const server = http.createServer((req, res) => {
+  if (req.method === "GET" && req.url === "/events") {
+    res.writeHead(200, {
+      "Content-Type": "text/event-stream",
+      "Cache-Control": "no-cache",
+      Connection: "keep-alive"
+    })
+    res.write("event: ready\ndata: {\"ok\":true}\n\n")
+    clients.add(res)
+    req.on("close", () => clients.delete(res))
+    return
+  }
+
+  if (req.method === "POST" && req.url === "/tool") {
+    let raw = ""
+    req.setEncoding("utf-8")
+    req.on("data", chunk => { raw += chunk })
+    req.on("end", () => {
+      let payload
+      try {
+        payload = JSON.parse(raw || "{}")
+      } catch {
+        res.writeHead(400, { "Content-Type": "application/json" })
+        res.end(JSON.stringify({ error: "Invalid JSON body" }))
+        return
+      }
+
+      const tool = payload.tool
+      const input = payload.input || {}
+      if (tool !== "summarize") {
+        res.writeHead(404, { "Content-Type": "application/json" })
+        res.end(JSON.stringify({ error: `Unknown tool: ${tool}` }))
+        return
+      }
+
+      broadcast("tool_called", { tool, input })
+      const result = summarize(input.text)
+      const out = {
+        tool,
+        mode: "sse-http",
+        result,
+        words_in: String(input.text || "").trim() ? String(input.text).trim().split(/\s+/).length : 0,
+        words_out: result ? result.split(/\s+/).length : 0
+      }
+      broadcast("tool_done", out)
+      res.writeHead(200, { "Content-Type": "application/json" })
+      res.end(JSON.stringify(out))
+    })
+    return
+  }
+
+  res.writeHead(404, { "Content-Type": "application/json" })
+  res.end(JSON.stringify({ error: "Not found" }))
+})
+
+server.listen(PORT, "127.0.0.1", () => {
+  console.log(`MCP SSE demo server listening on http://127.0.0.1:${PORT}`)
+  console.log("Endpoints: POST /tool, GET /events")
+})

package/examples/mcp-stdio/install-demo.js

@@ -0,0 +1,78 @@
+#!/usr/bin/env node
+
+const fs = require("fs");
+const os = require("os");
+const path = require("path");
+
+const CACHE_DIR = path.join(os.homedir(), ".supercli");
+const CACHE_FILE = path.join(CACHE_DIR, "config.json");
+const ROOT = path.resolve(__dirname, "..", "..");
+const SERVER_SCRIPT = path.join(ROOT, "examples", "mcp-stdio", "server.js");
+
+function ensureDir(dir) {
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+}
+
+function readConfig() {
+  if (!fs.existsSync(CACHE_FILE)) {
+    return {
+      version: "1",
+      ttl: 3600,
+      mcp_servers: [],
+      specs: [],
+      commands: [],
+    };
+  }
+  try {
+    return JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+  } catch {
+    return {
+      version: "1",
+      ttl: 3600,
+      mcp_servers: [],
+      specs: [],
+      commands: [],
+    };
+  }
+}
+
+function upsertCommand(config, command) {
+  const idx = config.commands.findIndex(
+    (c) =>
+      c.namespace === command.namespace &&
+      c.resource === command.resource &&
+      c.action === command.action,
+  );
+  if (idx >= 0) config.commands[idx] = command;
+  else config.commands.push(command);
+}
+
+function main() {
+  ensureDir(CACHE_DIR);
+  const config = readConfig();
+  if (!Array.isArray(config.commands)) config.commands = [];
+  if (!Array.isArray(config.mcp_servers)) config.mcp_servers = [];
+  if (!Array.isArray(config.specs)) config.specs = [];
+
+  upsertCommand(config, {
+    _id: "command:ai.text.summarize",
+    namespace: "ai",
+    resource: "text",
+    action: "summarize",
+    description: "Mock summarize using local stdio MCP server",
+    adapter: "mcp",
+    adapterConfig: {
+      tool: "summarize",
+      command: `node ${SERVER_SCRIPT}`,
+    },
+    args: [{ name: "text", type: "string", required: true }],
+  });
+
+  config.fetchedAt = Date.now();
+  fs.writeFileSync(CACHE_FILE, JSON.stringify(config, null, 2));
+  process.stdout.write(
+    `Installed demo command ai.text.summarize in ${CACHE_FILE}\n`,
+  );
+}
+
+main();

package/examples/mcp-stdio/server.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+
+function summarize(text) {
+  const normalized = String(text || "").trim().replace(/\s+/g, " ")
+  if (!normalized) return ""
+  const words = normalized.split(" ")
+  if (words.length <= 12) return normalized
+  return words.slice(0, 12).join(" ") + " ..."
+}
+
+async function main() {
+  const chunks = []
+  for await (const chunk of process.stdin) chunks.push(chunk)
+
+  let payload
+  try {
+    payload = JSON.parse(Buffer.concat(chunks).toString("utf-8") || "{}")
+  } catch {
+    process.stderr.write("Invalid JSON input\n")
+    process.exit(1)
+    return
+  }
+
+  const tool = payload.tool
+  const input = payload.input || {}
+
+  if (tool !== "summarize") {
+    process.stderr.write(`Unknown tool: ${tool}\n`)
+    process.exit(1)
+    return
+  }
+
+  const source = input.text || ""
+  const summary = summarize(source)
+  const out = {
+    tool,
+    mode: "stdio",
+    result: summary,
+    words_in: String(source).trim() ? String(source).trim().split(/\s+/).length : 0,
+    words_out: summary ? summary.split(/\s+/).length : 0
+  }
+
+  process.stdout.write(JSON.stringify(out))
+  process.exit(0)
+}
+
+main().catch((err) => {
+  process.stderr.write(`${err.message}\n`)
+  process.exit(1)
+})

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "superacli",
+  "version": "1.0.0",
+  "description": "Config-driven, AI-friendly dynamic CLI",
+  "main": "server/app.js",
+  "bin": {
+    "dcli": "./cli/supercli.js",
+    "scli": "./cli/supercli.js",
+    "supercli": "./cli/supercli.js"
+  },
+  "scripts": {
+    "start": "node server/app.js",
+    "dev": "node server/app.js"
+  },
+  "dependencies": {
+    "dotenv": "^17.3.1",
+    "ejs": "^3.1.9",
+    "express": "^4.18.2",
+    "mongodb": "^6.3.0"
+  }
+}

package/server/app.js

@@ -0,0 +1,59 @@
+const express = require("express");
+const path = require("path");
+const { getStorage } = require("./storage/adapter");
+
+const commandsRouter = require("./routes/commands");
+const configRouter = require("./routes/config");
+const specsRouter = require("./routes/specs");
+const mcpRouter = require("./routes/mcp");
+const plansRouter = require("./routes/plans");
+const jobsRouter = require("./routes/jobs");
+const askRouter = require("./routes/ask");
+
+const PORT = process.env.PORT || 3000;
+
+const app = express();
+
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+app.set("view engine", "ejs");
+app.set("views", path.join(__dirname, "views"));
+
+app.use("/static", express.static(path.join(__dirname, "public")));
+
+// API routes
+app.use("/api/config", configRouter);
+app.use("/api/commands", commandsRouter);
+app.use("/api/specs", specsRouter);
+app.use("/api/mcp", mcpRouter);
+app.use("/api/plans", plansRouter);
+app.use("/api/jobs", jobsRouter);
+app.use("/api/ask", askRouter);
+
+// Tree/command endpoints under /api (config router handles them)
+app.use("/api", configRouter);
+
+// UI page redirects
+app.get("/", (req, res) => res.redirect("/api/commands"));
+app.get("/commands", (req, res) => res.redirect("/api/commands"));
+app.get("/commands/new", (req, res) => res.redirect("/api/commands/new"));
+app.get("/specs", (req, res) => res.redirect("/api/specs"));
+app.get("/mcp", (req, res) => res.redirect("/api/mcp"));
+app.get("/jobs", (req, res) => res.redirect("/api/jobs"));
+
+async function start() {
+  try {
+    // Initialize storage singleton
+    getStorage();
+
+    app.listen(PORT, () => {
+      console.log(`SUPERCLI server running on http://localhost:${PORT}`);
+    });
+  } catch (err) {
+    console.error("Failed to start:", err.message);
+    process.exit(1);
+  }
+}
+
+start();

package/server/public/app.js

@@ -0,0 +1,18 @@
+// SUPERCLI Client-side utilities
+// Highlight active nav item based on current URL
+(function () {
+  const path = window.location.pathname;
+  if (path.startsWith("/api/commands") || path.startsWith("/commands")) {
+    const el = document.getElementById("nav-commands");
+    if (el) el.classList.add("nav-active");
+  } else if (path.startsWith("/api/specs") || path.startsWith("/specs")) {
+    const el = document.getElementById("nav-specs");
+    if (el) el.classList.add("nav-active");
+  } else if (path.startsWith("/api/mcp") || path.startsWith("/mcp")) {
+    const el = document.getElementById("nav-mcp");
+    if (el) el.classList.add("nav-active");
+  } else if (path.startsWith("/api/jobs") || path.startsWith("/jobs")) {
+    const el = document.getElementById("nav-jobs");
+    if (el) el.classList.add("nav-active");
+  }
+})();

package/server/routes/ask.js

@@ -0,0 +1,92 @@
+const { Router } = require("express")
+const configService = require("../services/configService")
+
+const router = Router()
+
+router.post("/", async (req, res) => {
+  const { query } = req.body
+  if (!query) return res.status(400).json({ error: "Missing query parameter" })
+
+  const baseUrl = process.env.OPENAI_BASE_URL
+  const model = process.env.OPENAI_MODEL || "gpt-3.5-turbo"
+  const apiKey = process.env.OPENAI_API_KEY || "dummy"
+
+  if (!baseUrl) {
+    return res.status(501).json({ error: "Server is not configured for LLM completions (OPENAI_BASE_URL is missing)" })
+  }
+
+  try {
+    const namespaces = await configService.getNamespaces()
+    const allDefs = []
+    
+    // Build a compact representation of all CLI commands
+    for (const ns of namespaces) {
+      const resources = await configService.getResources(ns)
+      for (const res of resources) {
+        const actions = await configService.getActions(ns, res)
+        for (const act of actions) {
+          const cmd = await configService.getCommand(ns, res, act)
+          if (!cmd) continue
+          const argList = (cmd.args || []).map(a => `--${a.name}${a.required ? " (required)" : ""}`).join(" ")
+          allDefs.push(`- ${ns} ${res} ${act} ${argList} : ${cmd.description || "no desc"}`)
+        }
+      }
+    }
+
+    const systemPrompt = `You are an AI CLI assistant router.
+Available commands:
+${allDefs.join("\n")}
+
+The user wants to accomplish a goal. Map their goal into a sequence of CLI commands to run.
+Respond STRICTLY with a valid JSON array of steps. For example:
+[
+  { "command": "aws.instances.list", "args": { "region": "us-east-1" } },
+  { "command": "ai.summarize.text", "args": { "text": "{{step.0.data.summary}}" } }
+]
+Do not wrap it in markdown. Do not include any other text.`
+
+    const r = await fetch(`${baseUrl.replace(/\/$/, "")}/chat/completions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: "system", content: systemPrompt },
+          { role: "user", content: query }
+        ],
+        temperature: 0
+      })
+    })
+
+    if (!r.ok) {
+      const txt = await r.text()
+      throw new Error(`LLM Error ${r.status}: ${txt}`)
+    }
+
+    const data = await r.json()
+    const content = data.choices && data.choices[0] && data.choices[0].message && data.choices[0].message.content
+    if (!content) throw new Error("Invalid response format from LLM")
+    
+    // Attempt to extract JSON if the model ignored instructions and wrapped in markdown
+    let jsonStr = content.trim()
+    if (jsonStr.startsWith("```json")) {
+      jsonStr = jsonStr.replace(/^```json/, "").replace(/```$/, "").trim()
+    } else if (jsonStr.startsWith("```")) {
+      jsonStr = jsonStr.replace(/^```/, "").replace(/```$/, "").trim()
+    }
+
+    const steps = JSON.parse(jsonStr)
+    if (!Array.isArray(steps)) {
+      throw new Error("LLM did not return a JSON array")
+    }
+
+    res.json({ steps })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/commands.js

@@ -0,0 +1,126 @@
+const { Router } = require("express")
+const { getStorage } = require("../storage/adapter")
+const { bumpVersion } = require("../services/configService")
+
+const router = Router()
+
+// Helper to list all commands
+async function getAllCommands() {
+  const storage = getStorage()
+  const keys = await storage.listKeys("command:")
+  const commands = await Promise.all(keys.map(k => storage.get(k)))
+  return commands.sort((a, b) => a._id.localeCompare(b._id))
+}
+
+// GET /api/commands
+router.get("/", async (req, res) => {
+  try {
+    const commands = await getAllCommands()
+    if (req.query.format !== "json" && req.accepts("html") && !req.xhr && !req.headers["x-requested-with"]) {
+      return res.render("commands", { commands })
+    }
+    res.json(commands)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/commands/new
+router.get("/new", async (req, res) => {
+  res.render("command-edit", { command: null })
+})
+
+// GET /api/commands/:id/edit
+router.get("/:id/edit", async (req, res) => {
+  try {
+    const storage = getStorage()
+    // id could be URL encoded if it's a natural key
+    const id = decodeURIComponent(req.params.id)
+    const command = await storage.get(id)
+    if (!command) return res.status(404).send("Not found")
+    res.render("command-edit", { command })
+  } catch (err) {
+    res.status(500).send(err.message)
+  }
+})
+
+// POST /api/commands
+router.post("/", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const { namespace, resource, action, description, adapter, adapterConfig, args } = req.body
+    const key = `command:${namespace}.${resource}.${action}`
+    
+    // Check if exists? Overwrite is allowed for now, acts as upsert.
+
+    const doc = {
+      _id: key, // Store the key inside the document as well
+      namespace,
+      resource,
+      action,
+      description: description || "",
+      adapter: adapter || "http",
+      adapterConfig: typeof adapterConfig === "string" ? JSON.parse(adapterConfig || "{}") : (adapterConfig || {}),
+      args: Array.isArray(args) ? args : JSON.parse(args || "[]"),
+      createdAt: new Date(),
+      updatedAt: new Date()
+    }
+
+    await storage.set(key, doc)
+    await bumpVersion()
+    
+    if (req.headers["content-type"]?.includes("urlencoded")) {
+      return res.redirect("/api/commands")
+    }
+    res.status(201).json(doc)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// PUT /api/commands/:id
+router.put("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    const { namespace, resource, action, description, adapter, adapterConfig, args } = req.body
+    
+    // If n/r/a changed, the ID changes, we should delete the old one.
+    const newKey = `command:${namespace}.${resource}.${action}`
+    if (newKey !== id) {
+      await storage.delete(id)
+    }
+
+    const update = {
+      _id: newKey,
+      namespace,
+      resource,
+      action,
+      description: description || "",
+      adapter: adapter || "http",
+      adapterConfig: typeof adapterConfig === "string" ? JSON.parse(adapterConfig || "{}") : (adapterConfig || {}),
+      args: Array.isArray(args) ? args : JSON.parse(args || "[]"),
+      updatedAt: new Date()
+    }
+    await storage.set(newKey, update)
+    await bumpVersion()
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// DELETE /api/commands/:id
+router.delete("/:id", async (req, res) => {
+  try {
+    const storage = getStorage()
+    const id = decodeURIComponent(req.params.id)
+    await storage.delete(id)
+    await bumpVersion()
+    res.json({ ok: true })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router

package/server/routes/config.js

@@ -0,0 +1,58 @@
+const { Router } = require("express")
+const configService = require("../services/configService")
+
+const router = Router()
+
+// GET /api/config — full CLI config
+router.get("/", async (req, res) => {
+  try {
+    const config = await configService.getCLIConfig()
+    config.features = { ask: !!process.env.OPENAI_BASE_URL }
+    res.json(config)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/tree — list namespaces
+router.get("/tree", async (req, res) => {
+  try {
+    const namespaces = await configService.getNamespaces()
+    res.json({ namespaces })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/tree/:ns — list resources in namespace
+router.get("/tree/:ns", async (req, res) => {
+  try {
+    const resources = await configService.getResources(req.params.ns)
+    res.json({ resources })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/tree/:ns/:res — list actions
+router.get("/tree/:ns/:res", async (req, res) => {
+  try {
+    const actions = await configService.getActions(req.params.ns, req.params.res)
+    res.json({ actions })
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+// GET /api/command/:ns/:res/:act — full command spec
+router.get("/command/:ns/:res/:act", async (req, res) => {
+  try {
+    const cmd = await configService.getCommand(req.params.ns, req.params.res, req.params.act)
+    if (!cmd) return res.status(404).json({ error: "Command not found" })
+    res.json(cmd)
+  } catch (err) {
+    res.status(500).json({ error: err.message })
+  }
+})
+
+module.exports = router