superacli 1.0.1 → 1.1.2

package/__tests__/shell-adapter.test.js

@@ -0,0 +1,90 @@
+const { execute } = require("../cli/adapters/shell")
+const { spawn } = require("child_process")
+const EventEmitter = require("events")
+
+jest.mock("child_process")
+
+describe("shell adapter", () => {
+  let mockChild
+
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockChild = new EventEmitter()
+    mockChild.stdout = new EventEmitter()
+    mockChild.stdout.setEncoding = jest.fn()
+    mockChild.stderr = new EventEmitter()
+    mockChild.stderr.setEncoding = jest.fn()
+    mockChild.kill = jest.fn()
+    spawn.mockReturnValue(mockChild)
+  })
+
+  test("interpolates script and executes", async () => {
+    const promise = execute({
+      adapterConfig: { script: "echo {{name}}", parseJson: false }
+    }, { name: 'world"quoted' })
+
+    mockChild.stdout.emit("data", "hello world\\\"quoted")
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ raw: "hello world\\\"quoted" })
+    expect(spawn).toHaveBeenCalledWith("bash", ["-lc", "echo world\\\"quoted"], expect.anything())
+  })
+
+  test("handles JSON parsing", async () => {
+    const promise = execute({
+      adapterConfig: { script: "echo '{\"ok\":true}'" }
+    }, {})
+
+    mockChild.stdout.emit("data", '{"ok":true}')
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ ok: true })
+  })
+
+  test("handles non-JSON when parseJson is true", async () => {
+    const promise = execute({
+      adapterConfig: { script: "echo not-json" }
+    }, {})
+
+    mockChild.stdout.emit("data", "not-json")
+    mockChild.emit("close", 0)
+
+    const result = await promise
+    expect(result).toEqual({ raw: "not-json" })
+  })
+
+  test("handles timeout", async () => {
+    jest.useFakeTimers()
+    const promise = execute({
+      adapterConfig: { script: "sleep 10", timeout_ms: 100 }
+    }, {})
+
+    jest.advanceTimersByTime(200)
+
+    await expect(promise).rejects.toThrow(/timed out after 100ms/)
+    jest.useRealTimers()
+  })
+
+  test("handles spawn error", async () => {
+    const promise = execute({
+      adapterConfig: { script: "fail" }
+    }, {})
+
+    mockChild.emit("error", new Error("spawn fail"))
+
+    await expect(promise).rejects.toThrow("Failed to start shell adapter")
+  })
+
+  test("handles non-zero exit", async () => {
+    const promise = execute({
+      adapterConfig: { script: "exit 1" }
+    }, {})
+
+    mockChild.stderr.emit("data", "error details")
+    mockChild.emit("close", 1)
+
+    await expect(promise).rejects.toThrow(/Shell adapter failed.*error details/)
+  })
+})

package/__tests__/skills-catalog.test.js

@@ -0,0 +1,98 @@
+const fs = require("fs")
+const os = require("os")
+const path = require("path")
+
+const {
+  addProvider,
+  removeProvider,
+  getProvider,
+  listProviders,
+  syncCatalog,
+  listCatalogSkills,
+  searchCatalog,
+  getCatalogSkill,
+  readIndex
+} = require("../cli/skills-catalog")
+
+describe("skills catalog", () => {
+  let tempHome
+  let skillsRoot
+
+  beforeEach(() => {
+    tempHome = fs.mkdtempSync(path.join(os.tmpdir(), "supercli-skills-"))
+    process.env.SUPERCLI_HOME = tempHome
+    skillsRoot = path.join(tempHome, "kb", "skills")
+    fs.mkdirSync(path.join(skillsRoot, "sample"), { recursive: true })
+    fs.writeFileSync(
+      path.join(skillsRoot, "sample", "SKILL.md"),
+      "---\nskill_name: sample_skill\ndescription: Sample description\n---\n\n# Sample\n\ncontent"
+    )
+  })
+
+  afterEach(() => {
+    delete process.env.SUPERCLI_HOME
+    fs.rmSync(tempHome, { recursive: true, force: true })
+  })
+
+  test("provider lifecycle and sync catalog", () => {
+    addProvider({ name: "testkb", type: "local_fs", roots: [skillsRoot], enabled: true })
+
+    const providers = listProviders()
+    expect(providers.find(p => p.name === "testkb")).toBeTruthy()
+    expect(getProvider("testkb")).toBeTruthy()
+    expect(getProvider("missing")).toBeNull()
+
+    const index = syncCatalog()
+    expect(index.skills.length).toBeGreaterThan(0)
+
+    const listed = listCatalogSkills({ provider: "testkb" })
+    expect(listed.find(s => s.id === "testkb:sample_skill")).toBeTruthy()
+
+    const searched = searchCatalog("sample", { provider: "testkb" })
+    expect(searched.length).toBeGreaterThan(0)
+    
+    // Coverage for line 181
+    const searchedDesc = searchCatalog("description")
+    expect(searchedDesc.length).toBeGreaterThan(0)
+
+    const full = getCatalogSkill("testkb:sample_skill")
+    expect(full).toBeTruthy()
+    expect(full.markdown).toContain("skill_name: sample_skill")
+
+    const removed = removeProvider("testkb")
+    expect(removed).toBe(true)
+  })
+
+  test("readJson error coverage", () => {
+    const providersFile = path.join(tempHome, "skills-providers.json")
+    fs.writeFileSync(providersFile, "invalid-json")
+    // Should fallback to default providers
+    const providers = listProviders()
+    expect(providers.length).toBeGreaterThan(0)
+  })
+
+  test("readIndex coverage", () => {
+    expect(readIndex().skills).toEqual([])
+    const indexFile = path.join(tempHome, "skills-index.json")
+    fs.writeFileSync(indexFile, "null")
+    expect(readIndex().skills).toEqual([])
+  })
+
+  test("remote_static provider is indexed", () => {
+    addProvider({
+      name: "agency-agents",
+      type: "remote_static",
+      enabled: true,
+      entries: [
+        {
+          id: "engineering.engineering-frontend-developer",
+          name: "Frontend Developer",
+          source_url: "https://raw.githubusercontent.com/msitarzewski/agency-agents/main/engineering/engineering-frontend-developer.md"
+        }
+      ]
+    })
+
+    const index = syncCatalog()
+    expect(index.skills.find(s => s.id === "agency-agents:engineering.engineering-frontend-developer")).toBeTruthy()
+  })
+})

package/__tests__/skills.test.js

@@ -0,0 +1,442 @@
+const {
+  normalizeSkillId,
+  buildCommandSkillMarkdown,
+  buildTeachSkillMarkdown,
+  buildPluginsUsageSkillMarkdown,
+  listSkillsMetadata,
+  handleSkillsCommand,
+  renderYamlObject
+} = require("../cli/skills")
+const catalog = require("../cli/skills-catalog")
+
+jest.mock("../cli/skills-catalog")
+
+describe("skills", () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test("renderYamlObject coverage", () => {
+    // Line 66: non-object in array
+    expect(renderYamlObject([1, 2])).toBe("- 1\n- 2")
+    // Line 72: top-level scalar
+    expect(renderYamlObject("scalar")).toBe("\"scalar\"")
+    // Empty array
+    expect(renderYamlObject([])).toBe("[]")
+    // Array with empty object
+    expect(renderYamlObject([{}])).toBe("- {}")
+    // Object with multiple keys
+    expect(renderYamlObject({ a: 1, b: 2 })).toBe("a: 1\nb: 2")
+  })
+
+  test("normalizeSkillId validates dotted ids", () => {
+    expect(normalizeSkillId("a.b.c")).toEqual({ id: "a.b.c", namespace: "a", resource: "b", action: "c" })
+    expect(normalizeSkillId("a.b")).toBeNull()
+    expect(normalizeSkillId(123)).toBeNull()
+  })
+
+  test("normalizeSkillId handles edge cases", () => {
+    expect(normalizeSkillId("")).toBeNull()
+    expect(normalizeSkillId(null)).toBeNull()
+    expect(normalizeSkillId("a..c")).toBeNull()
+    expect(normalizeSkillId(".a.b")).toBeNull()
+    expect(normalizeSkillId("  a.b.c  ")).toEqual({ id: "a.b.c", namespace: "a", resource: "b", action: "c" })
+  })
+
+  test("buildCommandSkillMarkdown returns frontmatter and examples", () => {
+    const md = buildCommandSkillMarkdown({
+      namespace: "ai",
+      resource: "text",
+      action: "summarize",
+      description: "Summarize text",
+      adapter: "mcp",
+      adapterConfig: { tool: "summarize" },
+      args: [{ name: "text", type: "string", required: true }]
+    })
+
+    expect(md.startsWith("---\n")).toBe(true)
+    expect(md).toContain("skill_name: \"ai_text_summarize\"")
+    expect(md).toContain("supercli ai text summarize --text <text> --json")
+  })
+
+  test("buildCommandSkillMarkdown with showDag includes dag", () => {
+    const md = buildCommandSkillMarkdown({
+      namespace: "ai",
+      resource: "text",
+      action: "summarize",
+      description: "Summarize text",
+      args: [{ name: "text", type: "string", required: true }]
+    }, { showDag: true })
+
+    expect(md).toContain("dag:")
+    expect(md).toContain("type:")
+  })
+
+  test("buildCommandSkillMarkdown with optional args", () => {
+    const md = buildCommandSkillMarkdown({
+      namespace: "ai",
+      resource: "text",
+      action: "summarize",
+      description: "Summarize text",
+      args: [{ name: "text", type: "string", required: false }]
+    })
+
+    expect(md).toContain("--text <text>")
+  })
+
+  test("buildTeachSkillMarkdown can include dag", () => {
+    const md = buildTeachSkillMarkdown({ showDag: true })
+    expect(md).toContain("skill_name: \"teach_skills_usage\"")
+    expect(md).toContain("dag:")
+  })
+
+  test("buildPluginsUsageSkillMarkdown returns markdown", () => {
+    const md = buildPluginsUsageSkillMarkdown({ showDag: true })
+    expect(md).toContain("skill_name: \"plugins_registry_usage\"")
+    expect(md).toContain("dag:")
+    expect(md).toContain("# Instruction")
+  })
+
+  test("listSkillsMetadata keeps name and description only", () => {
+    const skills = listSkillsMetadata({
+      commands: [{ namespace: "x", resource: "y", action: "z", description: "desc" }]
+    })
+    expect(skills).toEqual(expect.arrayContaining([{ name: "x.y.z", description: "desc" }]))
+    const item = skills.find(s => s.name === "x.y.z")
+    expect(item.description).toBe("desc")
+  })
+
+  describe("handleSkillsCommand", () => {
+    let mockOutput, mockOutputHumanTable, mockOutputError
+
+    beforeEach(() => {
+      mockOutput = jest.fn()
+      mockOutputHumanTable = jest.fn()
+      mockOutputError = jest.fn()
+    })
+
+    test("list subcommand", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "list"],
+        flags: {},
+        config: { commands: [{ namespace: "a", resource: "b", action: "c", description: "test" }] },
+        humanMode: false,
+        output: mockOutput,
+        outputHumanTable: mockOutputHumanTable,
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      const payload = mockOutput.mock.calls[0][0]
+      expect(payload.skills).toEqual(expect.arrayContaining([{ name: "a.b.c", description: "test" }]))
+    })
+
+    test("list human mode", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "list"],
+        flags: {},
+        config: { commands: [{ namespace: "a", resource: "b", action: "c", description: "test" }] },
+        humanMode: true,
+        output: mockOutput,
+        outputHumanTable: mockOutputHumanTable,
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputHumanTable).toHaveBeenCalled()
+      consoleSpy.mockRestore()
+    })
+
+    test("list --catalog subcommand", () => {
+      catalog.listCatalogSkills.mockReturnValue([{ name: "cat-skill" }])
+      catalog.readIndex.mockReturnValue({ updated_at: "now" })
+      
+      const result = handleSkillsCommand({
+        positional: ["skills", "list"],
+        flags: { catalog: true },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(catalog.listCatalogSkills).toHaveBeenCalled()
+      expect(mockOutput).toHaveBeenCalledWith(expect.objectContaining({
+        skills: [{ name: "cat-skill" }]
+      }))
+    })
+
+    test("teach subcommand", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "teach"],
+        flags: { format: "skill.md" },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("teach_skills_usage"))
+      consoleSpy.mockRestore()
+    })
+
+    test("teach subcommand invalid format", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "teach"],
+        flags: { format: "json" },
+        config: {},
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+    })
+
+    test("get subcommand (local)", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "a.b.c"],
+        flags: { format: "skill.md" },
+        config: { commands: [{ namespace: "a", resource: "b", action: "c", description: "test" }] },
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("skill_name: \"a_b_c\""))
+      consoleSpy.mockRestore()
+    })
+
+    test("get subcommand (plugins usage)", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "plugins.registry.usage"],
+        flags: { format: "skill.md" },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("skill_name: \"plugins_registry_usage\""))
+      consoleSpy.mockRestore()
+    })
+
+    test("get subcommand (catalog)", () => {
+      const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+      catalog.getCatalogSkill.mockReturnValue({ markdown: "catalog-md" })
+      
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "provider:skill"],
+        flags: { format: "skill.md" },
+        config: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(catalog.getCatalogSkill).toHaveBeenCalledWith("provider:skill")
+      expect(consoleSpy).toHaveBeenCalledWith("catalog-md")
+      consoleSpy.mockRestore()
+    })
+
+    test("get subcommand (catalog not found)", () => {
+      catalog.getCatalogSkill.mockReturnValue(null)
+      
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "provider:missing"],
+        flags: { format: "skill.md" },
+        config: {},
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 92 }))
+    })
+
+    test("get subcommand invalid format", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "a.b.c"],
+        flags: { format: "json" },
+        config: {},
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+    })
+
+    test("get subcommand invalid skill id", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "invalid"],
+        flags: { format: "skill.md" },
+        config: {},
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+    })
+
+    test("get subcommand command not found", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "get", "missing.res.act"],
+        flags: { format: "skill.md" },
+        config: { commands: [] },
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 92 }))
+    })
+
+    test("sync subcommand", () => {
+      catalog.syncCatalog.mockReturnValue({ updated_at: "now", providers: 1, skills: [1, 2] })
+      
+      const result = handleSkillsCommand({
+        positional: ["skills", "sync"],
+        flags: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(catalog.syncCatalog).toHaveBeenCalled()
+      expect(mockOutput).toHaveBeenCalledWith(expect.objectContaining({ ok: true, skills: 2 }))
+    })
+
+    test("search subcommand", () => {
+      catalog.searchCatalog.mockReturnValue([{ name: "found" }])
+      
+      const result = handleSkillsCommand({
+        positional: ["skills", "search", "query"],
+        flags: {},
+        output: mockOutput
+      })
+
+      expect(result).toBe(true)
+      expect(catalog.searchCatalog).toHaveBeenCalledWith("query", expect.anything())
+      expect(mockOutput).toHaveBeenCalledWith({ skills: [{ name: "found" }] })
+    })
+
+    test("search subcommand validation error", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "search"],
+        flags: {},
+        outputError: mockOutputError
+      })
+
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+    })
+
+    describe("providers subcommand", () => {
+      test("list", () => {
+        catalog.listProviders.mockReturnValue([{ name: "p1" }])
+        handleSkillsCommand({
+          positional: ["skills", "providers", "list"],
+          flags: {},
+          output: mockOutput
+        })
+        expect(mockOutput).toHaveBeenCalledWith({ providers: [{ name: "p1" }] })
+      })
+
+      test("list human mode", () => {
+        const consoleSpy = jest.spyOn(console, "log").mockImplementation()
+        catalog.listProviders.mockReturnValue([{ name: "p1" }])
+        handleSkillsCommand({
+          positional: ["skills", "providers", "list"],
+          flags: {},
+          humanMode: true,
+          outputHumanTable: mockOutputHumanTable
+        })
+        expect(mockOutputHumanTable).toHaveBeenCalled()
+        consoleSpy.mockRestore()
+      })
+
+      test("add", () => {
+        catalog.addProvider.mockReturnValue({ name: "p1" })
+        handleSkillsCommand({
+          positional: ["skills", "providers", "add"],
+          flags: { name: "p1", roots: "r1" },
+          output: mockOutput
+        })
+        expect(catalog.addProvider).toHaveBeenCalledWith(expect.objectContaining({ name: "p1", roots: ["r1"] }))
+      })
+
+      test("add validation error", () => {
+        handleSkillsCommand({
+          positional: ["skills", "providers", "add"],
+          flags: { name: "p1" }, // missing roots
+          outputError: mockOutputError
+        })
+        expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+      })
+
+      test("remove", () => {
+        catalog.removeProvider.mockReturnValue(true)
+        handleSkillsCommand({
+          positional: ["skills", "providers", "remove", "p1"],
+          flags: {},
+          output: mockOutput
+        })
+        expect(catalog.removeProvider).toHaveBeenCalledWith("p1")
+        expect(mockOutput).toHaveBeenCalledWith({ ok: true, removed: true })
+      })
+
+      test("remove validation error", () => {
+        handleSkillsCommand({
+          positional: ["skills", "providers", "remove"],
+          flags: {},
+          outputError: mockOutputError
+        })
+        expect(mockOutputError).toHaveBeenCalled()
+      })
+
+      test("show", () => {
+        catalog.getProvider.mockReturnValue({ name: "p1" })
+        handleSkillsCommand({
+          positional: ["skills", "providers", "show", "p1"],
+          flags: {},
+          output: mockOutput
+        })
+        expect(catalog.getProvider).toHaveBeenCalledWith("p1")
+        expect(mockOutput).toHaveBeenCalledWith({ provider: { name: "p1" } })
+      })
+
+      test("show not found", () => {
+        catalog.getProvider.mockReturnValue(null)
+        handleSkillsCommand({
+          positional: ["skills", "providers", "show", "p1"],
+          flags: {},
+          outputError: mockOutputError
+        })
+        expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 92 }))
+      })
+
+      test("show validation error", () => {
+        handleSkillsCommand({
+          positional: ["skills", "providers", "show"],
+          flags: {},
+          outputError: mockOutputError
+        })
+        expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+      })
+
+      test("unknown action", () => {
+        handleSkillsCommand({
+          positional: ["skills", "providers", "unknown"],
+          flags: {},
+          outputError: mockOutputError
+        })
+        expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+      })
+    })
+
+    test("unknown subcommand", () => {
+      const result = handleSkillsCommand({
+        positional: ["skills", "unknown"],
+        flags: {},
+        outputError: mockOutputError
+      })
+      expect(result).toBe(true)
+      expect(mockOutputError).toHaveBeenCalledWith(expect.objectContaining({ code: 85 }))
+    })
+  })
+})