@sweny-ai/core 0.1.51 → 0.1.52

package/dist/__tests__/publish.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/publish.test.js

@@ -0,0 +1,146 @@
+import { describe, it, expect, beforeAll, afterAll } from "vitest";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { validateWorkflowFile, validateSkillDir } from "../cli/publish.js";
+describe("validateWorkflowFile", () => {
+    let tmpDir;
+    beforeAll(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-publish-test-"));
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("validates a correct workflow file", () => {
+        const file = path.join(tmpDir, "good.yml");
+        fs.writeFileSync(file, `id: test-workflow
+name: Test
+description: A test workflow
+entry: start
+nodes:
+  start:
+    name: Start
+    instruction: Do something.
+    skills: [github]
+edges: []
+`);
+        const result = validateWorkflowFile(file);
+        expect(result.valid).toBe(true);
+        expect(result.id).toBe("test-workflow");
+        expect(result.name).toBe("Test");
+        expect(result.nodeCount).toBe(1);
+        expect(result.edgeCount).toBe(0);
+        expect(result.errors).toEqual([]);
+    });
+    it("rejects a non-existent file", () => {
+        const result = validateWorkflowFile(path.join(tmpDir, "nope.yml"));
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toBe("File not found");
+    });
+    it("rejects invalid YAML", () => {
+        const file = path.join(tmpDir, "bad.yml");
+        fs.writeFileSync(file, "{{invalid yaml");
+        const result = validateWorkflowFile(file);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toMatch(/Invalid YAML/);
+    });
+    it("rejects a workflow missing required fields", () => {
+        const file = path.join(tmpDir, "incomplete.yml");
+        fs.writeFileSync(file, "id: test\nname: Test\n");
+        const result = validateWorkflowFile(file);
+        expect(result.valid).toBe(false);
+        expect(result.errors.length).toBeGreaterThan(0);
+    });
+});
+describe("validateSkillDir", () => {
+    let tmpDir;
+    beforeAll(() => {
+        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-skill-test-"));
+    });
+    afterAll(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    it("validates a correct instruction skill", () => {
+        const skillDir = path.join(tmpDir, "my-skill");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: my-skill
+description: A test skill
+---
+
+When reviewing code, check for security issues first.
+`);
+        const result = validateSkillDir(skillDir);
+        expect(result.valid).toBe(true);
+        expect(result.id).toBe("my-skill");
+        expect(result.hasInstruction).toBe(true);
+        expect(result.hasMcp).toBe(false);
+    });
+    it("validates a correct MCP skill", () => {
+        const skillDir = path.join(tmpDir, "mcp-skill");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: mcp-skill
+description: A test MCP skill
+mcp:
+  command: npx
+  args: ["-y", "@company/server"]
+---
+`);
+        const result = validateSkillDir(skillDir);
+        expect(result.valid).toBe(true);
+        expect(result.hasMcp).toBe(true);
+    });
+    it("rejects a directory without SKILL.md", () => {
+        const emptyDir = path.join(tmpDir, "empty");
+        fs.mkdirSync(emptyDir, { recursive: true });
+        const result = validateSkillDir(emptyDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toBe("SKILL.md not found in directory");
+    });
+    it("rejects a skill with no frontmatter", () => {
+        const skillDir = path.join(tmpDir, "no-fm");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), "Just some text");
+        const result = validateSkillDir(skillDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toBe("No YAML frontmatter found");
+    });
+    it("rejects an invalid skill ID", () => {
+        const skillDir = path.join(tmpDir, "Bad-Name");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: Bad-Name
+---
+
+Some instruction.
+`);
+        const result = validateSkillDir(skillDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors[0]).toMatch(/Invalid skill ID/);
+    });
+    it("rejects a skill with mismatched directory name", () => {
+        const skillDir = path.join(tmpDir, "wrong-dir");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: correct-name
+---
+
+Some instruction.
+`);
+        const result = validateSkillDir(skillDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain(`Directory name "wrong-dir" doesn't match skill name "correct-name"`);
+    });
+    it("rejects a skill with no instruction and no MCP", () => {
+        const skillDir = path.join(tmpDir, "empty-skill");
+        fs.mkdirSync(skillDir, { recursive: true });
+        fs.writeFileSync(path.join(skillDir, "SKILL.md"), `---
+name: empty-skill
+---
+`);
+        const result = validateSkillDir(skillDir);
+        expect(result.valid).toBe(false);
+        expect(result.errors).toContain("Skill must have an instruction body or an mcp config");
+    });
+});

package/dist/__tests__/schema.test.js

@@ -1,5 +1,5 @@
 import { describe, it, expect } from "vitest";
-import { workflowZ, nodeZ, edgeZ, skillZ, toolZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
+import { workflowZ, nodeZ, edgeZ, skillZ, toolZ, mcpServerConfigZ, skillDefinitionZ, parseWorkflow, validateWorkflow, workflowJsonSchema, } from "../schema.js";
 import { triageWorkflow, implementWorkflow } from "../workflows/index.js";
 // ─── Test fixtures ───────────────────────────────────────────────
 const validWorkflow = {
@@ -100,6 +100,128 @@ describe("Zod schemas", () => {
             expect(result.tools).toHaveLength(1);
         });
     });
+    describe("mcpServerConfigZ", () => {
+        it("accepts stdio config", () => {
+            const result = mcpServerConfigZ.parse({ command: "npx", args: ["-y", "@company/tool-server"] });
+            expect(result.command).toBe("npx");
+        });
+        it("accepts http config", () => {
+            const result = mcpServerConfigZ.parse({
+                url: "https://mcp.example.com",
+                headers: { Authorization: "Bearer token" },
+            });
+            expect(result.url).toBe("https://mcp.example.com");
+        });
+        it("accepts explicit type", () => {
+            const result = mcpServerConfigZ.parse({ type: "stdio", command: "node", args: ["server.js"] });
+            expect(result.type).toBe("stdio");
+        });
+        it("accepts env field", () => {
+            const result = mcpServerConfigZ.parse({
+                command: "npx",
+                args: ["-y", "server"],
+                env: { API_KEY: "Company API key" },
+            });
+            expect(result.env).toEqual({ API_KEY: "Company API key" });
+        });
+        it("rejects config with neither command nor url", () => {
+            expect(() => mcpServerConfigZ.parse({ args: ["foo"] })).toThrow("MCP server must have either command (stdio) or url (HTTP)");
+        });
+    });
+    describe("skillDefinitionZ", () => {
+        it("accepts instruction-only skill", () => {
+            const result = skillDefinitionZ.parse({
+                name: "Code Standards",
+                instruction: "Follow our coding conventions...",
+            });
+            expect(result.instruction).toBe("Follow our coding conventions...");
+        });
+        it("accepts mcp-only skill", () => {
+            const result = skillDefinitionZ.parse({ mcp: { command: "npx", args: ["-y", "server"] } });
+            expect(result.mcp?.command).toBe("npx");
+        });
+        it("accepts both instruction and mcp", () => {
+            const result = skillDefinitionZ.parse({
+                instruction: "Use this server for...",
+                mcp: { url: "https://mcp.example.com" },
+            });
+            expect(result.instruction).toBeDefined();
+            expect(result.mcp).toBeDefined();
+        });
+        it("rejects skill with neither instruction nor mcp", () => {
+            expect(() => skillDefinitionZ.parse({ name: "Empty" })).toThrow("Inline skill must provide instruction, mcp, or both");
+        });
+    });
+    describe("skillZ with new fields", () => {
+        it("accepts skill with instruction and no tools", () => {
+            const result = skillZ.parse({
+                id: "code-standards",
+                name: "Code Standards",
+                description: "Team coding conventions",
+                category: "general",
+                instruction: "Follow camelCase naming...",
+            });
+            expect(result.tools).toEqual([]);
+            expect(result.instruction).toBe("Follow camelCase naming...");
+        });
+        it("accepts skill with mcp and no tools", () => {
+            const result = skillZ.parse({
+                id: "our-crm",
+                name: "Our CRM",
+                description: "CRM integration",
+                category: "general",
+                mcp: { url: "https://crm.example.com/mcp" },
+            });
+            expect(result.tools).toEqual([]);
+            expect(result.mcp?.url).toBe("https://crm.example.com/mcp");
+        });
+        it("rejects skill with no tools, no instruction, no mcp", () => {
+            expect(() => skillZ.parse({ id: "empty", name: "Empty", description: "Nothing", category: "general" })).toThrow("Skill must provide at least one of: tools, instruction, or mcp");
+        });
+        it("defaults tools to empty array", () => {
+            const result = skillZ.parse({
+                id: "x",
+                name: "X",
+                description: "X",
+                category: "general",
+                instruction: "do stuff",
+            });
+            expect(result.tools).toEqual([]);
+        });
+        it("defaults config to empty object", () => {
+            const result = skillZ.parse({
+                id: "x",
+                name: "X",
+                description: "X",
+                category: "general",
+                instruction: "do stuff",
+            });
+            expect(result.config).toEqual({});
+        });
+    });
+    describe("workflowZ with skills", () => {
+        it("parses workflow with inline skills", () => {
+            const result = workflowZ.parse({
+                id: "test",
+                name: "Test",
+                entry: "a",
+                nodes: { a: { name: "A", instruction: "Do A", skills: ["my-skill"] } },
+                edges: [],
+                skills: { "my-skill": { name: "My Skill", instruction: "Custom guidance here" } },
+            });
+            expect(result.skills?.["my-skill"]?.instruction).toBe("Custom guidance here");
+        });
+        it("defaults skills to empty object", () => {
+            const result = workflowZ.parse({
+                id: "x",
+                name: "X",
+                entry: "a",
+                nodes: { a: { name: "A", instruction: "Do A" } },
+                edges: [],
+            });
+            expect(result.skills).toEqual({});
+        });
+    });
     describe("workflowZ", () => {
         it("parses a valid workflow", () => {
             const raw = JSON.parse(JSON.stringify(validWorkflow));
@@ -251,6 +373,39 @@ describe("validateWorkflow", () => {
         const errors = validateWorkflow(empty);
         expect(errors).toContainEqual(expect.objectContaining({ code: "MISSING_ENTRY" }));
     });
+    it("recognizes inline workflow skills as known", () => {
+        const wf = {
+            ...validWorkflow,
+            nodes: { ...validWorkflow.nodes, a: { ...validWorkflow.nodes.a, skills: ["custom-rubric"] } },
+            skills: { "custom-rubric": { instruction: "Score things 1-5" } },
+        };
+        const errors = validateWorkflow(wf, new Set(["github"]));
+        expect(errors.filter((e) => e.code === "UNKNOWN_SKILL")).toEqual([]);
+    });
+    it("rejects inline skills with neither instruction nor mcp", () => {
+        const wf = {
+            ...validWorkflow,
+            skills: { "bad-skill": { name: "Bad" } },
+        };
+        const errors = validateWorkflow(wf);
+        expect(errors).toContainEqual(expect.objectContaining({ code: "INVALID_INLINE_SKILL" }));
+    });
+    it("accepts inline skills with instruction only", () => {
+        const wf = {
+            ...validWorkflow,
+            skills: { "ok-skill": { instruction: "Do something" } },
+        };
+        const errors = validateWorkflow(wf);
+        expect(errors.filter((e) => e.code === "INVALID_INLINE_SKILL")).toEqual([]);
+    });
+    it("accepts inline skills with mcp only", () => {
+        const wf = {
+            ...validWorkflow,
+            skills: { "mcp-skill": { mcp: { command: "npx", args: ["-y", "server"] } } },
+        };
+        const errors = validateWorkflow(wf);
+        expect(errors.filter((e) => e.code === "INVALID_INLINE_SKILL")).toEqual([]);
+    });
 });
 // ─── JSON Schema shape tests ─────────────────────────────────────
 describe("workflowJsonSchema", () => {

package/dist/__tests__/skills.test.js

@@ -9,7 +9,7 @@ import { sentry } from "../skills/sentry.js";
 import { datadog } from "../skills/datadog.js";
 import { notification } from "../skills/notification.js";
 import { createSkillMap } from "../skills/index.js";
-import { loadCustomSkills, configuredSkills } from "../skills/custom-loader.js";
+import { loadCustomSkills, discoverSkills, configuredSkills } from "../skills/custom-loader.js";
 // ─── Helpers ─────────────────────────────────────────────────────
 const mockCtx = (config = {}) => ({
     config,
@@ -399,13 +399,15 @@ describe("configuredSkills with custom skills", () => {
         expect(ids).toContain("notification");
         expect(ids).toContain("slack");
     });
-    it("built-in skills take precedence over custom skills with same ID", () => {
-        writeSkill("notification", `---\nname: notification\ndescription: Custom override attempt\n---\nBody`);
+    it("custom skills override built-in ID but merge tools", () => {
+        writeSkill("notification", `---\nname: notification\ndescription: Custom override\n---\nCustom notification guidance.`);
         const skills = configuredSkills({}, tmpDir);
         const notif = skills.filter((s) => s.id === "notification");
         expect(notif).toHaveLength(1);
-        // Should be the built-in (has tools), not the custom one (tools: [])
+        // Built-in tools are preserved
         expect(notif[0].tools.length).toBeGreaterThan(0);
+        // Custom instruction is added
+        expect(notif[0].instruction).toBe("Custom notification guidance.");
     });
     it("custom skills are usable in createSkillMap", () => {
         writeSkill("extract-colors", `---\nname: extract-colors\ndescription: Route color extraction\n---\nBody`);
@@ -415,3 +417,132 @@ describe("configuredSkills with custom skills", () => {
         expect(map.get("extract-colors").tools).toEqual([]);
     });
 });
+// ─── Multi-directory discovery tests ─────────────────────────────
+describe("discoverSkills (multi-directory)", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), "sweny-discover-test-"));
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeSkillAt(base, dirName, content) {
+        const dir = join(tmpDir, base, "skills", dirName);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "SKILL.md"), content);
+    }
+    it("discovers skills from .sweny/skills/", () => {
+        writeSkillAt(".sweny", "my-skill", `---\nname: my-skill\ndescription: A skill\n---\nDo things well.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(1);
+        expect(skills[0].id).toBe("my-skill");
+    });
+    it("discovers skills from .claude/skills/", () => {
+        writeSkillAt(".claude", "claude-skill", `---\nname: claude-skill\ndescription: Claude\n---\nInstructions.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(1);
+        expect(skills[0].id).toBe("claude-skill");
+    });
+    it("discovers skills from .agents/skills/", () => {
+        writeSkillAt(".agents", "agent-skill", `---\nname: agent-skill\ndescription: Agent\n---\nBody.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(1);
+    });
+    it("discovers skills from .gemini/skills/", () => {
+        writeSkillAt(".gemini", "gemini-skill", `---\nname: gemini-skill\ndescription: Gemini\n---\nBody.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(1);
+    });
+    it("higher-priority directory wins on ID collision", () => {
+        writeSkillAt(".sweny", "shared", `---\nname: shared\ndescription: From sweny\n---\nSweny instructions.`);
+        writeSkillAt(".claude", "shared", `---\nname: shared\ndescription: From claude\n---\nClaude instructions.`);
+        const skills = discoverSkills(tmpDir);
+        const shared = skills.find((s) => s.id === "shared");
+        expect(shared.description).toBe("From sweny");
+        expect(shared.instruction).toBe("Sweny instructions.");
+    });
+    it("captures markdown body as instruction", () => {
+        writeSkillAt(".sweny", "code-standards", `---
+name: code-standards
+description: Coding conventions
+---
+
+When writing TypeScript:
+- Use camelCase for variables
+- Use PascalCase for types`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills[0].instruction).toContain("Use camelCase for variables");
+        expect(skills[0].instruction).toContain("Use PascalCase for types");
+    });
+    it("parses mcp from frontmatter", () => {
+        writeSkillAt(".sweny", "our-crm", `---
+name: our-crm
+description: CRM integration
+mcp:
+  command: npx
+  args:
+    - -y
+    - "@company/crm-server"
+  env:
+    API_KEY: CRM API key
+---
+
+Use the CRM tools to look up customer data.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills[0].mcp).toEqual({
+            type: "stdio",
+            command: "npx",
+            args: ["-y", "@company/crm-server"],
+            env: { API_KEY: "CRM API key" },
+        });
+        expect(skills[0].instruction).toContain("Use the CRM tools");
+    });
+    it("parses mcp with url (HTTP transport)", () => {
+        writeSkillAt(".sweny", "http-tool", `---
+name: http-tool
+description: HTTP MCP
+mcp:
+  url: https://mcp.example.com
+  headers:
+    Authorization: Bearer token
+---
+
+Instructions.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills[0].mcp?.url).toBe("https://mcp.example.com");
+    });
+    it("returns empty array when no skill directories exist", () => {
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+    it("merges skills from all directories", () => {
+        writeSkillAt(".sweny", "skill-a", `---\nname: skill-a\ndescription: A\n---\nA.`);
+        writeSkillAt(".claude", "skill-b", `---\nname: skill-b\ndescription: B\n---\nB.`);
+        writeSkillAt(".agents", "skill-c", `---\nname: skill-c\ndescription: C\n---\nC.`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(3);
+        const ids = skills.map((s) => s.id).sort();
+        expect(ids).toEqual(["skill-a", "skill-b", "skill-c"]);
+    });
+    it("rejects skill IDs with invalid characters", () => {
+        writeSkillAt(".sweny", "valid-skill", `---\nname: ../../etc/passwd\ndescription: malicious\n---\nBody`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(0);
+    });
+    it("rejects skill IDs with uppercase", () => {
+        writeSkillAt(".sweny", "MySkill", `---\nname: MySkill\ndescription: bad\n---\nBody`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(0);
+    });
+    it("rejects skill IDs with consecutive hyphens", () => {
+        writeSkillAt(".sweny", "bad--name", `---\nname: bad--name\ndescription: bad\n---\nBody`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(0);
+    });
+    it("rejects skill IDs longer than 64 chars", () => {
+        const longId = "a".repeat(65);
+        writeSkillAt(".sweny", longId, `---\nname: ${longId}\ndescription: long\n---\nBody`);
+        const skills = discoverSkills(tmpDir);
+        expect(skills).toHaveLength(0);
+    });
+});

package/dist/__tests__/templates.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/__tests__/templates.test.js

@@ -0,0 +1,49 @@
+import { describe, it, expect } from "vitest";
+import { parse } from "yaml";
+import { WORKFLOW_TEMPLATES } from "../cli/templates.js";
+import { parseWorkflow, validateWorkflow } from "../schema.js";
+describe("WORKFLOW_TEMPLATES", () => {
+    it("has at least 4 templates", () => {
+        expect(WORKFLOW_TEMPLATES.length).toBeGreaterThanOrEqual(4);
+    });
+    it("each template has unique id, name, and description", () => {
+        const ids = new Set();
+        for (const t of WORKFLOW_TEMPLATES) {
+            expect(t.id).toBeTruthy();
+            expect(t.name).toBeTruthy();
+            expect(t.description).toBeTruthy();
+            expect(ids.has(t.id)).toBe(false);
+            ids.add(t.id);
+        }
+    });
+    for (const template of WORKFLOW_TEMPLATES) {
+        describe(`template: ${template.id}`, () => {
+            it("parses as valid YAML", () => {
+                const parsed = parse(template.yaml);
+                expect(parsed).toBeDefined();
+                expect(parsed.id).toBe(template.id);
+            });
+            it("passes parseWorkflow validation", () => {
+                const parsed = parse(template.yaml);
+                const workflow = parseWorkflow(parsed);
+                expect(workflow.id).toBe(template.id);
+                expect(Object.keys(workflow.nodes).length).toBeGreaterThan(0);
+            });
+            it("passes validateWorkflow with no errors", () => {
+                const parsed = parse(template.yaml);
+                const workflow = parseWorkflow(parsed);
+                const errors = validateWorkflow(workflow);
+                expect(errors).toEqual([]);
+            });
+            it("uses only the github skill", () => {
+                const parsed = parse(template.yaml);
+                const workflow = parseWorkflow(parsed);
+                for (const node of Object.values(workflow.nodes)) {
+                    for (const skill of node.skills) {
+                        expect(skill).toBe("github");
+                    }
+                }
+            });
+        });
+    }
+});

package/dist/__tests__/version-consistency.test.js

@@ -96,8 +96,8 @@ describe("README", () => {
     it("does not use the old Recipes heading", () => {
         expect(readme).not.toMatch(/^## Recipes$/m);
     });
-    it("has an Actions section with the multi-repo table", () => {
-        expect(readme).toMatch(/^## Actions$/m);
+    it("has a GitHub Actions section with the multi-repo table", () => {
+        expect(readme).toMatch(/^## GitHub Actions$/m);
         expect(readme).toContain("swenyai/triage@v1");
         expect(readme).toContain("swenyai/e2e@v1");
         expect(readme).toContain(`swenyai/sweny@${CURRENT_ACTION_VERSION}`);

package/dist/cli/init.d.ts

@@ -1,6 +1,9 @@
 /**
  * sweny init — Interactive setup wizard
  *
+ * Workflow-first: pick a template or describe what you want, then SWEny
+ * infers which skills are needed and only asks for those credentials.
+ *
  * Pure functions for file generation + thin @clack/prompts interactive layer.
  * Tests cover the pure functions; the interactive wizard is thin glue.
  */
@@ -22,10 +25,25 @@ export interface GitRemoteInfo {
     provider: "github" | "gitlab";
     remote: string;
 }
+/**
+ * Maps skill IDs (as used in workflow nodes) to the credentials they require.
+ * When a workflow uses a skill, we collect only those credentials.
+ */
+export declare const SKILL_CREDENTIALS: Record<string, Credential[]>;
 export declare const PROVIDER_CREDENTIALS: Record<string, Credential[]>;
+/**
+ * Extract all unique skill IDs from a workflow template YAML string.
+ */
+export declare function extractSkillsFromYaml(yaml: string): string[];
+/**
+ * Gather credentials required for a set of skills.
+ * Always includes ANTHROPIC_API_KEY. Deduplicates by key name.
+ */
+export declare function collectCredentialsForSkills(skills: string[]): Credential[];
 /**
  * Gather all unique credentials required for the selected providers.
  * Always includes ANTHROPIC_API_KEY. Deduplicates by key name.
+ * @deprecated Use collectCredentialsForSkills instead — kept for backward compat.
  */
 export declare function collectCredentials(selections: InitSelections): Credential[];
 /**
@@ -34,9 +52,9 @@ export declare function collectCredentials(selections: InitSelections): Credenti
  */
 export declare function detectGitRemote(cwd: string): GitRemoteInfo | null;
 /**
- * Generate .sweny.yml content from selections.
+ * Generate .sweny.yml content from inferred providers.
  */
-export declare function buildSwenyYml(selections: InitSelections): string;
+export declare function buildSwenyYml(sourceControl: string, observability: string | null, issueTracker: string): string;
 /**
  * Generate .env template with comments for each credential.
  */
@@ -47,7 +65,12 @@ export declare function buildEnvTemplate(credentials: Credential[]): string;
  */
 export declare function buildActionWorkflow(credentials: Credential[], cronExpression: string): string;
 /**
- * Interactive setup wizard — prompts the user through provider selection,
- * then generates `.sweny.yml`, `.env`, and an optional GitHub Action workflow.
+ * Interactive setup wizard — workflow-first approach.
+ *
+ * 1. Detect git remote (infer source control)
+ * 2. Pick a workflow template
+ * 3. Infer providers from workflow skills
+ * 4. Collect only the credentials those skills need
+ * 5. Generate files
  */
 export declare function runInit(): Promise<void>;