superacli 1.0.1 → 1.1.2

package/__tests__/ask.test.js

@@ -0,0 +1,327 @@
+const { handleAskCommand } = require("../cli/ask")
+const { execute } = require("../cli/executor")
+
+jest.mock("../cli/executor")
+
+describe("ask", () => {
+  let mockOutput
+  let mockOutputError
+  let consoleSpy
+
+  const mockConfig = {
+    commands: [
+      {
+        namespace: "test",
+        resource: "res",
+        action: "act",
+        description: "Test action",
+        args: [{ name: "foo", required: true }, { name: "bar", required: false }]
+      }
+    ],
+    features: { ask: true }
+  }
+
+  const mockContext = {
+    server: "http://api.test"
+  }
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockOutput = jest.fn()
+    mockOutputError = jest.fn()
+    consoleSpy = jest.spyOn(console, "log").mockImplementation()
+    global.fetch = jest.fn()
+    
+    // Clear relevant environment variables
+    delete process.env.OPENAI_BASE_URL
+    delete process.env.OPENAI_MODEL
+    delete process.env.OPENAI_API_KEY
+  })
+
+  afterEach(() => {
+    consoleSpy.mockRestore()
+  })
+
+  test("returns error if query is missing", async () => {
+    await handleAskCommand({
+      positional: ["ask"],
+      outputError: mockOutputError
+    })
+    expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+      code: 85,
+      type: "invalid_argument"
+    }))
+  })
+
+  test("returns error if 'ask' is not configured", async () => {
+    await handleAskCommand({
+      positional: ["ask", "help me"],
+      config: { features: {} },
+      context: {},
+      outputError: mockOutputError
+    })
+    expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+      code: 105,
+      type: "integration_error",
+      message: expect.stringContaining("not configured")
+    }))
+  })
+
+  describe("local LLM resolution", () => {
+    beforeEach(() => {
+      process.env.OPENAI_BASE_URL = "http://localhost:1234/v1"
+    })
+
+    test("successfully resolves and executes plan with multiple commands in config", async () => {
+      const mockConfigMulti = {
+        commands: [
+          { namespace: "test", resource: "res", action: "act1" },
+          { namespace: "test", resource: "res", action: "act2" },
+          { namespace: "other", resource: "res", action: "act" }
+        ],
+        features: { ask: true }
+      }
+      const mockSteps = [{ command: "test.res.act1" }]
+      
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: JSON.stringify(mockSteps) } }]
+        })
+      })
+      execute.mockResolvedValue({})
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: mockConfigMulti,
+        context: {},
+        output: mockOutput
+      })
+
+      expect(execute).toHaveBeenCalled()
+    })
+
+    test("strips markdown formatting from LLM response", async () => {
+      const mockSteps = [{ command: "test" }]
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: "```json\n" + JSON.stringify(mockSteps) + "\n```" } }]
+        })
+      })
+      execute.mockResolvedValue({})
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: mockConfig,
+        context: {},
+        output: mockOutput
+      })
+
+      expect(execute).toHaveBeenCalledWith(
+        expect.objectContaining({ adapterConfig: { steps: mockSteps } }),
+        expect.anything(),
+        expect.anything()
+      )
+    })
+
+    test("strips generic code blocks from LLM response", async () => {
+      const mockSteps = [{ command: "test" }]
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: "```\n" + JSON.stringify(mockSteps) + "\n```" } }]
+        })
+      })
+      execute.mockResolvedValue({})
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: mockConfig,
+        context: {},
+        output: mockOutput
+      })
+
+      expect(execute).toHaveBeenCalledWith(
+        expect.objectContaining({ adapterConfig: { steps: mockSteps } }),
+        expect.anything(),
+        expect.anything()
+      )
+    })
+
+    test("handles fetch failure from local LLM", async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        status: 401,
+        text: () => Promise.resolve("Unauthorized")
+      })
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: mockConfig,
+        context: {},
+        outputError: mockOutputError
+      })
+
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+        message: expect.stringContaining("Local LLM Error 401: Unauthorized")
+      }))
+    })
+
+    test("handles invalid response format from local LLM", async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ choices: [] })
+      })
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: mockConfig,
+        context: {},
+        outputError: mockOutputError
+      })
+
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+        message: "Invalid response format from local LLM"
+      }))
+    })
+
+    test("handles LLM response that is not a JSON array", async () => {
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: '{"not": "an array"}' } }]
+        })
+      })
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: mockConfig,
+        context: {},
+        outputError: mockOutputError
+      })
+
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+        message: "LLM did not return a JSON array"
+      }))
+    })
+  })
+
+  describe("remote LLM resolution", () => {
+    test("successfully resolves via server", async () => {
+      const mockSteps = [{ command: "remote.act" }]
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ steps: mockSteps })
+      })
+      execute.mockResolvedValue({ ok: true })
+
+      await handleAskCommand({
+        positional: ["ask", "remote", "query"],
+        config: { features: { ask: true } },
+        context: { server: "http://api.test" },
+        output: mockOutput
+      })
+
+      expect(global.fetch).toHaveBeenCalledWith(
+        "http://api.test/api/ask",
+        expect.objectContaining({ method: "POST" })
+      )
+      expect(execute).toHaveBeenCalledWith(
+        expect.objectContaining({ adapterConfig: { steps: mockSteps } }),
+        expect.anything(),
+        expect.anything()
+      )
+    })
+
+    test("handles server failure with error message", async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        statusText: "Bad Gateway",
+        json: () => Promise.resolve({ error: "Server too busy" })
+      })
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: { features: { ask: true } },
+        context: { server: "http://api.test" },
+        outputError: mockOutputError
+      })
+
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+        message: "Server LLM completion failed: Server too busy"
+      }))
+    })
+    
+    test("handles server failure with status text if no json error", async () => {
+      global.fetch.mockResolvedValue({
+        ok: false,
+        statusText: "Forbidden",
+        json: () => Promise.reject()
+      })
+
+      await handleAskCommand({
+        positional: ["ask", "test"],
+        config: { features: { ask: true } },
+        context: { server: "http://api.test" },
+        outputError: mockOutputError
+      })
+
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({
+        message: "Server LLM completion failed: Forbidden"
+      }))
+    })
+  })
+
+  describe("human mode", () => {
+    test("logs plan and success message with missing command parts and no description", async () => {
+      process.env.OPENAI_BASE_URL = "http://localhost"
+      const mockConfigWithHole = {
+        commands: [
+          { namespace: "test", resource: "res", action: "act" } // No description
+        ],
+        features: { ask: true }
+      }
+      
+      const mockSteps = [
+        { command: "test.res.act" } // No args
+      ]
+      
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({
+          choices: [{ message: { content: JSON.stringify(mockSteps) } }]
+        })
+      })
+      execute.mockResolvedValue({ data: "done" })
+
+      await handleAskCommand({
+        positional: ["ask", "do", "it"],
+        config: mockConfigWithHole,
+        context: mockContext,
+        humanMode: true
+      })
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Thinking... (local resolution)"))
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("1. test res act"))
+    })
+
+    test("logs plan in server mode", async () => {
+      const mockSteps = [{ command: "test.res.act", args: {} }]
+      global.fetch.mockResolvedValue({
+        ok: true,
+        json: () => Promise.resolve({ steps: mockSteps })
+      })
+      execute.mockResolvedValue({})
+
+      await handleAskCommand({
+        positional: ["ask", "do", "it"],
+        config: { features: { ask: true } },
+        context: { server: "http://api.test" },
+        humanMode: true
+      })
+
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("Thinking... (server resolution)"))
+    })
+  })
+})

package/__tests__/aws-plugin.test.js

@@ -0,0 +1,84 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeAwsBinary(dir) {
+  const bin = path.join(dir, "aws")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args.includes('--version')) { console.log('aws-cli/2.0.0-test Python/3.11'); process.exit(0); }",
+    "if (args[0] === 'sts' && args[1] === 'get-caller-identity') {",
+    "  console.log(JSON.stringify({ Account: '123456789012', Arn: 'arn:aws:iam::123456789012:user/mock', UserId: 'AIDTEST' }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("aws plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-aws-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-aws-"))
+  writeFakeAwsBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/aws --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove aws --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account identity wrapped command", () => {
+    const r = runNoServer("aws account identity --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("aws.account.identity")
+    expect(data.data.Account).toBe("123456789012")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("aws s3api list-buckets", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("aws.passthrough")
+    expect(data.data.args[0]).toBe("s3api")
+    expect(data.data.args[1]).toBe("list-buckets")
+  })
+
+  test("doctor reports aws dependency as healthy", () => {
+    const r = runNoServer("plugins doctor aws --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "aws" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/az-plugin.test.js

@@ -0,0 +1,84 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeAzBinary(dir) {
+  const bin = path.join(dir, "az")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === 'version') { console.log(JSON.stringify({ 'azure-cli': '2.0.0-test' })); process.exit(0); }",
+    "if (args[0] === 'account' && args[1] === 'show') {",
+    "  console.log(JSON.stringify({ id: 'sub-123', name: 'mock-subscription', state: 'Enabled' }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("az plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-az-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-az-"))
+  writeFakeAzBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/az --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove az --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes account show wrapped command", () => {
+    const r = runNoServer("az account show --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("az.account.show")
+    expect(data.data.id).toBe("sub-123")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("az group list", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("az.passthrough")
+    expect(data.data.args[0]).toBe("group")
+    expect(data.data.args[1]).toBe("list")
+  })
+
+  test("doctor reports az dependency as healthy", () => {
+    const r = runNoServer("plugins doctor az --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "az" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/builtin-adapter.test.js

@@ -0,0 +1,29 @@
+const { execute } = require("../cli/adapters/builtin")
+
+describe("builtin adapter", () => {
+  test("returns beads install steps", () => {
+    const result = execute({ adapterConfig: { builtin: "beads_install_steps" } })
+    expect(result.plugin).toBe("beads")
+    expect(result.install_steps).toContain("br --version")
+  })
+
+  test("returns gwc install steps", () => {
+    const result = execute({ adapterConfig: { builtin: "gwc_install_steps" } })
+    expect(result.plugin).toBe("gwc")
+    expect(result.install_steps).toContain("gws --version")
+  })
+
+  test("returns commiat install steps", () => {
+    const result = execute({ adapterConfig: { builtin: "commiat_install_steps" } })
+    expect(result.plugin).toBe("commiat")
+    expect(result.install_steps).toContain("commiat --version")
+  })
+
+  test("throws for unknown builtin action", () => {
+    expect(() => execute({ adapterConfig: { builtin: "unknown" } })).toThrow(/Unknown builtin action: unknown/)
+  })
+
+  test("throws for missing builtin action", () => {
+    expect(() => execute({ adapterConfig: {} })).toThrow(/Unknown builtin action: \(missing\)/)
+  })
+})

package/__tests__/cline-plugin.test.js

@@ -0,0 +1,109 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+function writeFakeClineBinary(dir) {
+  const bin = path.join(dir, "cline")
+  fs.writeFileSync(bin, [
+    "#!/usr/bin/env node",
+    "const args = process.argv.slice(2);",
+    "if (args[0] === '--version') { console.log('cline 3.71.0-test'); process.exit(0); }",
+    "if (args.includes('--json') && (args.includes('-a') || args.includes('-p'))) {",
+    "  const prompt = args[args.length - 1];",
+    "  console.log(JSON.stringify({ type: 'task_started', taskId: 'task-123' }));",
+    "  console.log(JSON.stringify({ type: 'say', say: 'task', text: prompt }));",
+    "  console.log(JSON.stringify({ type: 'say', say: 'completion_result', text: 'done', partial: false }));",
+    "  process.exit(0);",
+    "}",
+    "console.log(JSON.stringify({ ok: true, args }));"
+  ].join("\n"), "utf-8")
+  fs.chmodSync(bin, 0o755)
+  return bin
+}
+
+describe("cline plugin", () => {
+  const fakeDir = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-cline-"))
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-cline-"))
+  writeFakeClineBinary(fakeDir)
+  const env = { ...process.env, PATH: `${fakeDir}:${process.env.PATH || ""}`, SUPERCLI_HOME: tempHome }
+
+  beforeAll(() => {
+    runNoServer("plugins install ./plugins/cline --on-conflict replace --json", { env })
+  })
+
+  afterAll(() => {
+    runNoServer("plugins remove cline --json", { env })
+    fs.rmSync(fakeDir, { recursive: true, force: true })
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("routes cli version wrapped command", () => {
+    const r = runNoServer("cline cli version --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("cline.cli.version")
+    expect(data.data.raw).toBe("cline 3.71.0-test")
+  })
+
+  test("streams act-mode task output with final summary", () => {
+    const r = runNoServer("cline task run --prompt \"List files with most LOC\" --cwd . --timeout 30 --json", { env })
+    expect(r.ok).toBe(true)
+    const lines = r.output.split("\n").filter(Boolean).map(line => JSON.parse(line))
+    expect(lines[0].stream).toBe(true)
+    expect(lines[0].command).toBe("cline.task.run")
+    expect(lines[0].data.type).toBe("task_started")
+    expect(lines[1].data.say).toBe("task")
+    expect(lines[2].data.say).toBe("completion_result")
+    expect(lines[3].stream).toBeUndefined()
+    expect(lines[3].data.streamed).toBe(true)
+    expect(lines[3].data.event_count).toBe(3)
+  })
+
+  test("streams plan-mode task output with final summary", () => {
+    const r = runNoServer("cline task plan --prompt \"Plan auth refactor\" --json", { env })
+    expect(r.ok).toBe(true)
+    const lines = r.output.split("\n").filter(Boolean).map(line => JSON.parse(line))
+    expect(lines[0].command).toBe("cline.task.plan")
+    expect(lines[3].data.last_event.say).toBe("completion_result")
+  })
+
+  test("supports namespace passthrough", () => {
+    const r = runNoServer("cline --help --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.command).toBe("cline.passthrough")
+    expect(data.data.args).toContain("--help")
+    expect(data.data.args).toContain("--json")
+  })
+
+  test("doctor reports cline dependency as healthy", () => {
+    const r = runNoServer("plugins doctor cline --json", { env })
+    expect(r.ok).toBe(true)
+    const data = JSON.parse(r.output)
+    expect(data.ok).toBe(true)
+    expect(data.checks.some(c => c.type === "binary" && c.binary === "cline" && c.ok === true)).toBe(true)
+  })
+})

package/__tests__/cline-skill.test.js

@@ -0,0 +1,49 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+const { execSync } = require("child_process")
+
+const CLI = path.join(__dirname, "..", "cli", "supercli.js")
+
+function runNoServer(args, options = {}) {
+  try {
+    const env = { ...process.env }
+    delete env.SUPERCLI_SERVER
+    const out = execSync(`node ${CLI} ${args}`, {
+      encoding: "utf-8",
+      timeout: 15000,
+      env: { ...env, ...(options.env || {}) }
+    })
+    return { ok: true, output: out.trim(), code: 0 }
+  } catch (err) {
+    return {
+      ok: false,
+      output: (err.stdout || "").trim(),
+      stderr: (err.stderr || "").trim(),
+      code: err.status
+    }
+  }
+}
+
+describe("cline local skill", () => {
+  const tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "dcli-home-cline-skill-"))
+  const env = { ...process.env, SUPERCLI_HOME: tempHome }
+
+  afterAll(() => {
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("syncs and resolves repo skill", () => {
+    const sync = runNoServer("skills sync --json", { env })
+    expect(sync.ok).toBe(true)
+
+    const list = runNoServer("skills list --catalog --provider repo --json", { env })
+    expect(list.ok).toBe(true)
+    const listData = JSON.parse(list.output)
+    expect(listData.skills.some(skill => skill.id === "repo:cline-non-interactive")).toBe(true)
+
+    const get = runNoServer("skills get repo:cline-non-interactive", { env })
+    expect(get.ok).toBe(true)
+    expect(get.output).toContain("supercli cline task run")
+  })
+})