superacli 1.0.0

package/tests/test-cli.js

@@ -0,0 +1,367 @@
+#!/usr/bin/env node
+/**
+ * SUPERCLI CLI Integration Tests
+ * Tests all built-in commands, output modes, and error handling.
+ * Requires: server running on SUPERCLI_SERVER (default http://localhost:3000)
+ */
+
+const { execSync } = require("child_process");
+const path = require("path");
+
+const SERVER = process.env.SUPERCLI_SERVER || "http://127.0.0.1:3000";
+const CLI = path.join(__dirname, "..", "cli", "supercli.js");
+const SERVER_AVAILABLE = (() => {
+  try {
+    execSync(`curl -s --max-time 2 ${SERVER}/api/config > /dev/null`, {
+      stdio: "ignore",
+    });
+    return true;
+  } catch {
+    return false;
+  }
+})();
+const run = (args, opts = {}) => {
+  try {
+    const result = execSync(`SUPERCLI_SERVER=${SERVER} node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...process.env, SUPERCLI_SERVER: SERVER },
+      ...opts,
+    });
+    return { ok: true, output: result.trim() };
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status,
+    };
+  }
+};
+
+const runNoServer = (args, opts = {}) => {
+  try {
+    const env = { ...process.env };
+    delete env.SUPERCLI_SERVER;
+    const result = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env,
+      ...opts,
+    });
+    return { ok: true, output: result.trim() };
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status,
+    };
+  }
+};
+
+const parse = (r) => JSON.parse(r.output);
+
+let passed = 0;
+let failed = 0;
+
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } catch (err) {
+    failed++;
+    console.error(`  ❌ ${name}: ${err.message}`);
+  }
+}
+
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg || "Assertion failed");
+}
+
+console.log("\n⚡ SUPERCLI CLI Tests\n");
+
+// ── Seed test data ──
+console.log("  Seeding test data...");
+try {
+  execSync(
+    `curl -s -X POST ${SERVER}/api/commands -H 'Content-Type: application/json' -d '${JSON.stringify(
+      {
+        namespace: "test",
+        resource: "items",
+        action: "list",
+        adapter: "http",
+        adapterConfig: {
+          method: "GET",
+          url: "https://jsonplaceholder.typicode.com/posts?_limit=2",
+        },
+        args: [],
+        description: "List test items",
+      },
+    )}'`,
+    { encoding: "utf-8" },
+  );
+
+  execSync(
+    `curl -s -X POST ${SERVER}/api/commands -H 'Content-Type: application/json' -d '${JSON.stringify(
+      {
+        namespace: "test",
+        resource: "items",
+        action: "get",
+        adapter: "http",
+        adapterConfig: {
+          method: "GET",
+          url: "https://jsonplaceholder.typicode.com/posts/{id}",
+        },
+        args: [{ name: "id", type: "string", required: true }],
+        description: "Get test item by ID",
+      },
+    )}'`,
+    { encoding: "utf-8" },
+  );
+  console.log("  Seeded.\n");
+} catch (e) {
+  console.log("  (Seed skipped — data may already exist)\n");
+}
+
+// ── help ──
+test("help --json returns namespaces", () => {
+  const r = run("help --json");
+  assert(r.ok, "help should succeed");
+  const d = parse(r);
+  assert(d.version === "1.0", "version should be 1.0");
+  assert(Array.isArray(d.namespaces), "should have namespaces array");
+});
+
+// ── --help-json ──
+test("--help-json returns capability discovery", () => {
+  run("sync --json");
+  const r = run("--help-json");
+  assert(r.ok, "help-json should succeed");
+  const d = parse(r);
+  assert(d.name === "supercli", "name should be supercli");
+  assert(d.exit_codes, "should have exit_codes");
+  assert(d.flags, "should have flags");
+  assert(d.total_commands > 0, "should have commands");
+});
+
+test("--help-json hides sync when SUPERCLI_SERVER is not set", () => {
+  const r = runNoServer("--help-json");
+  assert(r.ok, "help-json without server should succeed");
+  const d = JSON.parse(r.output);
+  assert(
+    !d.commands.sync,
+    "sync should not be exposed without SUPERCLI_SERVER",
+  );
+});
+
+test("sync is unavailable when SUPERCLI_SERVER is not set", () => {
+  const r = runNoServer("sync --json");
+  assert(!r.ok, "sync should fail without SUPERCLI_SERVER");
+  assert(r.code === 92, "sync should be treated as unknown command");
+});
+
+test("plan works in local mode without SUPERCLI_SERVER", () => {
+  run("sync --json");
+  const r = runNoServer("plan test items list --json");
+  assert(r.ok, "local plan should succeed");
+  const d = JSON.parse(r.output);
+  assert(d.execution_mode === "local", "execution_mode should be local");
+  assert(d.persisted === false, "persisted should be false");
+  assert(
+    Array.isArray(d.steps) && d.steps.length > 0,
+    "should include plan steps",
+  );
+});
+
+test("local mcp registry can add/list/remove without SUPERCLI_SERVER", () => {
+  const add = runNoServer(
+    "mcp add local-demo --url http://127.0.0.1:7777 --json",
+  );
+  assert(add.ok, "mcp add should succeed");
+
+  const list = runNoServer("mcp list --json");
+  assert(list.ok, "mcp list should succeed");
+  const listData = JSON.parse(list.output);
+  assert(
+    Array.isArray(listData.mcp_servers),
+    "list should include mcp_servers",
+  );
+  assert(
+    listData.mcp_servers.find((s) => s.name === "local-demo"),
+    "list should include local-demo",
+  );
+
+  const remove = runNoServer("mcp remove local-demo --json");
+  assert(remove.ok, "mcp remove should succeed");
+});
+
+// ── config show ──
+test("config show returns cache info", () => {
+  // First sync
+  run("sync --json");
+  const r = run("config show --json");
+  assert(r.ok, "config show should succeed");
+  const d = parse(r);
+  assert(d.version, "should have version");
+  assert(d.cacheFile, "should have cacheFile");
+});
+
+test("sync command refreshes local config", () => {
+  if (!SERVER_AVAILABLE) return;
+  const r = run("sync --json");
+  assert(r.ok, "sync should succeed");
+  const d = parse(r);
+  assert(d.ok === true, "sync should return ok");
+});
+
+// ── commands ──
+test("commands --json lists all commands", () => {
+  const r = run("commands --json");
+  assert(r.ok, "commands should succeed");
+  const d = parse(r);
+  assert(Array.isArray(d.commands), "should have commands array");
+  assert(d.commands.length > 0, "should have at least 1 command");
+});
+
+// ── skills list ──
+test("skills list --json returns minimal metadata", () => {
+  const r = run("skills list --json");
+  assert(r.ok, "skills list should succeed");
+  const d = parse(r);
+  assert(Array.isArray(d.skills), "should return skills array");
+  assert(d.skills.length > 0, "should include at least one skill");
+  const first = d.skills[0];
+  assert(
+    Object.keys(first).sort().join(",") === "description,name",
+    "skill metadata should only include name and description",
+  );
+});
+
+// ── skills teach ──
+test("skills teach defaults to skill.md output", () => {
+  const r = run("skills teach");
+  assert(r.ok, "skills teach should succeed");
+  assert(r.output.startsWith("---"), "should start with frontmatter");
+  assert(
+    r.output.includes('skill_name: "teach_skills_usage"'),
+    "should include teach skill name",
+  );
+});
+
+// ── skills get ──
+test("skills get defaults to skill.md output", () => {
+  const r = run("skills get test.items.list");
+  assert(r.ok, "skills get should succeed");
+  assert(r.output.startsWith("---"), "should start with frontmatter");
+  assert(
+    r.output.includes('command: "test items list"'),
+    "should include command field",
+  );
+});
+
+test("skills get can include DAG section", () => {
+  const r = run("skills get test.items.list --show-dag");
+  assert(r.ok, "skills get with dag should succeed");
+  assert(r.output.includes("dag:"), "should include dag section");
+});
+
+// ── namespace listing ──
+test("namespace listing returns resources", () => {
+  const r = run("test --json");
+  assert(r.ok, "namespace should succeed");
+  const d = parse(r);
+  assert(d.namespace === "test", "namespace should be test");
+  assert(Array.isArray(d.resources), "should have resources");
+  assert(d.resources.includes("items"), "should include items");
+});
+
+// ── resource listing ──
+test("resource listing returns actions", () => {
+  const r = run("test items --json");
+  assert(r.ok, "resource should succeed");
+  const d = parse(r);
+  assert(d.resource === "items", "resource should be items");
+  assert(Array.isArray(d.actions), "should have actions");
+});
+
+// ── inspect ──
+test("inspect returns command schema", () => {
+  const r = run("inspect test items get --json");
+  assert(r.ok, "inspect should succeed");
+  const d = parse(r);
+  assert(d.command === "test.items.get", "command should match");
+  assert(d.input_schema, "should have input_schema");
+  assert(d.input_schema.required.includes("id"), "id should be required");
+});
+
+// ── --schema ──
+test("--schema returns input/output schema", () => {
+  const r = run("test items get --schema");
+  assert(r.ok, "schema should succeed");
+  const d = parse(r);
+  assert(d.input_schema, "should have input_schema");
+  assert(d.output_schema, "should have output_schema");
+});
+
+// ── execute command ──
+test("execute command returns data envelope", () => {
+  const r = run("test items list --json");
+  assert(r.ok, "execute should succeed");
+  const d = parse(r);
+  assert(d.version === "1.0", "version should be 1.0");
+  assert(d.command === "test.items.list", "command should match");
+  assert(d.duration_ms >= 0, "should have duration");
+  assert(Array.isArray(d.data), "data should be array");
+});
+
+// ── execute with path param ──
+test("execute with required arg substitutes path param", () => {
+  const r = run("test items get --id 1 --json");
+  assert(r.ok, "execute should succeed");
+  const d = parse(r);
+  assert(d.data.id === 1, "should return item with id 1");
+});
+
+// ── --compact flag ──
+test("--compact returns compressed keys", () => {
+  const r = run("test items list --compact");
+  assert(r.ok, "compact should succeed");
+  const d = parse(r);
+  assert(d.v === "1.0", "version key should be v");
+  assert(d.c === "test.items.list", "command key should be c");
+  assert(d.d, "data key should be d");
+});
+
+// ── validation error ──
+test("missing required arg returns validation error", () => {
+  const r = run("test items get --json");
+  assert(!r.ok, "should fail");
+  assert(r.code === 82, "exit code should be 82");
+  const d = JSON.parse(r.output);
+  assert(d.error.type === "validation_error", "should be validation_error");
+});
+
+// ── not found error ──
+test("unknown command returns resource_not_found", () => {
+  const r = run("nonexistent foo bar --json");
+  assert(!r.ok, "should fail");
+  assert(r.code === 92, "exit code should be 92");
+});
+
+// ── plan command ──
+test("plan creates execution plan", () => {
+  if (!SERVER_AVAILABLE) return;
+  const r = run("plan test items list --json");
+  assert(r.ok, "plan should succeed");
+  const d = parse(r);
+  assert(d.plan_id, "should have plan_id");
+  assert(Array.isArray(d.steps), "should have steps");
+  assert(d.steps.length >= 3, "should have at least 3 steps");
+  assert(d.risk_level, "should have risk_level");
+});
+
+// ── Results ──
+console.log(`\n  Results: ${passed} passed, ${failed} failed\n`);
+process.exit(failed > 0 ? 1 : 0);

package/tests/test-mcp.js

@@ -0,0 +1,189 @@
+#!/usr/bin/env node
+/**
+ * MCP Adapter Integration Test
+ * Spins up a mock MCP server, registers it, creates command, executes via CLI.
+ * Requires: server running on SUPERCLI_SERVER
+ */
+
+const http = require("http");
+const { exec } = require("child_process");
+const util = require("util");
+const path = require("path");
+
+const execAsync = util.promisify(exec);
+const SERVER = process.env.SUPERCLI_SERVER || "http://127.0.0.1:3000";
+const CLI = path.join(__dirname, "..", "cli", "supercli.js");
+const MCP_PORT = 4567;
+
+let passed = 0,
+  failed = 0;
+async function test(name, fn) {
+  try {
+    await fn();
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } catch (err) {
+    failed++;
+    console.error(`  ❌ ${name}: ${err.message}`);
+    console.error(err.stack);
+  }
+}
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg);
+}
+
+async function api(method, urlPath, body) {
+  const bodyStr = body ? JSON.stringify(body).replace(/'/g, "'\\''") : "";
+  const cmd = body
+    ? `curl -s -X ${method} '${SERVER}${urlPath}' -H 'Content-Type: application/json' -d '${bodyStr}'`
+    : `curl -s -X ${method} '${SERVER}${urlPath}'`;
+  const { stdout } = await execAsync(cmd, { encoding: "utf-8" });
+  return JSON.parse(stdout);
+}
+
+async function cli(args) {
+  try {
+    const { stdout } = await execAsync(
+      `SUPERCLI_SERVER=${SERVER} node ${CLI} ${args}`,
+      {
+        encoding: "utf-8",
+        timeout: 15000,
+        env: { ...process.env, SUPERCLI_SERVER: SERVER },
+      },
+    );
+    return { ok: true, data: JSON.parse(stdout.trim()) };
+  } catch (e) {
+    return {
+      ok: false,
+      output: (e.stdout || "").trim(),
+      code: e.code || e.status,
+    };
+  }
+}
+
+async function cliLocal(args) {
+  try {
+    const env = { ...process.env };
+    delete env.SUPERCLI_SERVER;
+    const { stdout } = await execAsync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env,
+    });
+    return { ok: true, data: JSON.parse(stdout.trim()) };
+  } catch (e) {
+    return {
+      ok: false,
+      output: (e.stdout || "").trim(),
+      code: e.code || e.status,
+    };
+  }
+}
+
+async function run() {
+  console.log("\n⚡ MCP Adapter Tests\n");
+
+  // ── Start mock MCP server ──
+  let mockServer;
+  await test("start mock MCP server", async () => {
+    return new Promise((resolve) => {
+      mockServer = http.createServer((req, res) => {
+        if (req.method === "POST" && req.url === "/tool") {
+          let body = "";
+          req.on("data", (c) => (body += c));
+          req.on("end", () => {
+            const { tool, input } = JSON.parse(body);
+            res.writeHead(200, { "Content-Type": "application/json" });
+            res.end(
+              JSON.stringify({
+                tool,
+                result: `Processed by ${tool}`,
+                input_received: input,
+              }),
+            );
+          });
+        } else {
+          res.writeHead(404);
+          res.end();
+        }
+      });
+      mockServer.listen(MCP_PORT, resolve);
+    });
+  });
+
+  await test("register MCP server", async () => {
+    const r = await api("POST", "/api/mcp", {
+      name: "test-mcp",
+      url: `http://127.0.0.1:${MCP_PORT}`,
+    });
+    assert(r.name === "test-mcp" || r.error, "should register");
+  });
+
+  await test("create MCP command", async () => {
+    const r = await api("POST", "/api/commands", {
+      namespace: "ai",
+      resource: "text",
+      action: "summarize",
+      adapter: "mcp",
+      adapterConfig: { server: "test-mcp", tool: "summarize" },
+      args: [{ name: "text", type: "string", required: true }],
+      description: "Summarize text via MCP",
+    });
+    assert(r.namespace === "ai", "should create command");
+  });
+
+  await test("sync CLI config", async () => {
+    const r = await cli("sync --json");
+    assert(r.ok, "sync should succeed");
+  });
+
+  await test("inspect MCP command", async () => {
+    const r = await cli("inspect ai text summarize --json");
+    assert(r.ok, "inspect should succeed");
+    assert(r.data.adapter === "mcp", "adapter should be mcp");
+  });
+
+  await test("execute MCP command", async () => {
+    const r = await cli("ai text summarize --text helloworld --json");
+    assert(
+      r.ok,
+      "execute should succeed. output: " +
+        (r.output || "none") +
+        " code: " +
+        r.code,
+    );
+    assert(r.data.command === "ai.text.summarize", "command should match");
+    assert(r.data.data.tool === "summarize", "tool should match");
+    assert(r.data.data.result, "should have result");
+  });
+
+  await test("execute MCP command in local mode", async () => {
+    const r = await cliLocal("ai text summarize --text localmode --json");
+    assert(
+      r.ok,
+      "local execute should succeed. output: " +
+        (r.output || "none") +
+        " code: " +
+        r.code,
+    );
+    assert(r.data.command === "ai.text.summarize", "command should match");
+    assert(r.data.data.tool === "summarize", "tool should match");
+    assert(r.data.data.result, "should have result");
+  });
+
+  await test("list MCP servers", async () => {
+    const r = await api("GET", "/api/mcp?format=json");
+    assert(Array.isArray(r), "should return array");
+    assert(
+      r.find((s) => s.name === "test-mcp"),
+      "should find test-mcp",
+    );
+  });
+
+  if (mockServer) mockServer.close();
+
+  console.log(`\n  Results: ${passed} passed, ${failed} failed\n`);
+  process.exit(failed > 0 ? 1 : 0);
+}
+
+run();

package/tests/test-openapi.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/**
+ * OpenAPI Adapter Integration Test
+ * Registers an OpenAPI spec, creates a command, executes via CLI.
+ * Requires: server running on SUPERCLI_SERVER
+ */
+
+const { execSync } = require("child_process");
+const path = require("path");
+
+const SERVER = process.env.SUPERCLI_SERVER || "http://127.0.0.1:3000";
+const CLI = path.join(__dirname, "..", "cli", "supercli.js");
+
+let passed = 0,
+  failed = 0;
+function test(name, fn) {
+  try {
+    fn();
+    passed++;
+    console.log(`  ✅ ${name}`);
+  } catch (err) {
+    failed++;
+    console.error(`  ❌ ${name}: ${err.message}`);
+  }
+}
+function assert(cond, msg) {
+  if (!cond) throw new Error(msg);
+}
+
+function api(method, urlPath, body) {
+  const bodyStr = body ? JSON.stringify(body).replace(/'/g, "'\\''") : "";
+  const cmd = body
+    ? `curl -s -X ${method} '${SERVER}${urlPath}' -H 'Content-Type: application/json' -d '${bodyStr}'`
+    : `curl -s -X ${method} '${SERVER}${urlPath}'`;
+  return JSON.parse(execSync(cmd, { encoding: "utf-8" }));
+}
+
+function cli(args) {
+  try {
+    const out = execSync(`SUPERCLI_SERVER=${SERVER} node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...process.env, SUPERCLI_SERVER: SERVER },
+    });
+    return { ok: true, data: JSON.parse(out.trim()) };
+  } catch (e) {
+    return { ok: false, output: (e.stdout || "").trim(), code: e.status };
+  }
+}
+
+console.log("\n⚡ OpenAPI Adapter Tests\n");
+
+test("register OpenAPI spec", () => {
+  const r = api("POST", "/api/specs", {
+    name: "jsonplaceholder",
+    url: "https://jsonplaceholder.typicode.com",
+    auth: "none",
+  });
+  assert(r.name === "jsonplaceholder" || r.error, "should register spec");
+});
+
+test("create command bound to spec", () => {
+  const r = api("POST", "/api/commands", {
+    namespace: "oapi",
+    resource: "todos",
+    action: "list",
+    adapter: "http",
+    adapterConfig: {
+      method: "GET",
+      url: "https://jsonplaceholder.typicode.com/todos?_limit=3",
+    },
+    args: [],
+    description: "List todos via OpenAPI-style command",
+  });
+  assert(r.namespace === "oapi", "should create command");
+});
+
+test("CLI config sync", () => {
+  const r = cli("sync --json");
+  assert(r.ok, "sync should succeed");
+});
+
+test("execute openapi-bound command", () => {
+  const r = cli("oapi todos list --json");
+  assert(r.ok, "execute should succeed");
+  assert(r.data.command === "oapi.todos.list", "command should match");
+  assert(Array.isArray(r.data.data), "should return array");
+  assert(r.data.data.length === 3, "should return 3 items");
+});
+
+test("list specs via API", () => {
+  const r = api("GET", "/api/specs?format=json");
+  assert(Array.isArray(r), "should return array");
+  assert(
+    r.find((s) => s.name === "jsonplaceholder"),
+    "should find registered spec",
+  );
+});
+
+console.log(`\n  Results: ${passed} passed, ${failed} failed\n`);
+process.exit(failed > 0 ? 1 : 0);