@sweny-ai/core 0.1.51 → 0.1.53

package/dist/cli/{init.test.js → new.test.js}

@@ -3,7 +3,7 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import * as os from "node:os";
 import { parse as parseYaml } from "yaml";
-import { collectCredentials, detectGitRemote, buildSwenyYml, buildEnvTemplate, buildActionWorkflow, PROVIDER_CREDENTIALS, } from "./init.js";
+import { collectCredentials, collectCredentialsForSkills, extractSkillsFromYaml, detectGitRemote, buildSwenyYml, buildEnvTemplate, buildActionWorkflow, runInit, runNew, PROVIDER_CREDENTIALS, SKILL_CREDENTIALS, } from "./new.js";
 // ── detectGitRemote ────────────────────────────────────────────────────
 describe("detectGitRemote", () => {
     const tmpDirs = [];
@@ -171,50 +171,17 @@ describe("PROVIDER_CREDENTIALS", () => {
 // ── buildSwenyYml ──────────────────────────────────────────────────────
 describe("buildSwenyYml", () => {
     it("includes all selected providers", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: "datadog",
-            issueTracker: "linear",
-            notification: "slack",
-            githubAction: true,
-            cronExpression: "0 8 * * 1",
-        });
+        const yml = buildSwenyYml("github", "datadog", "linear");
         expect(yml).toContain("source-control-provider: github");
         expect(yml).toContain("observability-provider: datadog");
         expect(yml).toContain("issue-tracker-provider: linear");
-        expect(yml).toContain("notification-provider: slack");
     });
     it("omits observability-provider when null", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: null,
-            issueTracker: "github-issues",
-            notification: "slack",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", null, "github-issues");
         expect(yml).not.toContain("observability-provider");
     });
-    it("omits notification-provider when console (default)", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: "sentry",
-            issueTracker: "github-issues",
-            notification: "console",
-            githubAction: false,
-            cronExpression: null,
-        });
-        expect(yml).not.toContain("notification-provider");
-    });
     it("includes header comments", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: null,
-            issueTracker: "github-issues",
-            notification: "console",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", null, "github-issues");
         expect(yml).toContain("# .sweny.yml");
     });
 });
@@ -407,49 +374,25 @@ describe("detectGitRemote — edge cases", () => {
 // ── buildSwenyYml: YAML validity ──────────────────────────────────────
 describe("buildSwenyYml — YAML validity", () => {
     it("generates valid YAML that can be parsed", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: "datadog",
-            issueTracker: "linear",
-            notification: "slack",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", "datadog", "linear");
         const parsed = parseYaml(yml);
         expect(parsed["source-control-provider"]).toBe("github");
         expect(parsed["observability-provider"]).toBe("datadog");
         expect(parsed["issue-tracker-provider"]).toBe("linear");
-        expect(parsed["notification-provider"]).toBe("slack");
     });
     it("generates valid YAML with minimal selections", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "github",
-            observability: null,
-            issueTracker: "github-issues",
-            notification: "console",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("github", null, "github-issues");
         const parsed = parseYaml(yml);
         expect(parsed["source-control-provider"]).toBe("github");
         expect(parsed["issue-tracker-provider"]).toBe("github-issues");
         expect(parsed["observability-provider"]).toBeUndefined();
-        expect(parsed["notification-provider"]).toBeUndefined();
     });
     it("uses correct key names matching config parser expectations", () => {
-        const yml = buildSwenyYml({
-            sourceControl: "gitlab",
-            observability: "sentry",
-            issueTracker: "jira",
-            notification: "teams",
-            githubAction: false,
-            cronExpression: null,
-        });
+        const yml = buildSwenyYml("gitlab", "sentry", "jira");
         // These are the exact keys the config parser reads
         expect(yml).toContain("source-control-provider:");
         expect(yml).toContain("observability-provider:");
         expect(yml).toContain("issue-tracker-provider:");
-        expect(yml).toContain("notification-provider:");
         // Must NOT contain the short form
         expect(yml).not.toMatch(/^source-control:/m);
         expect(yml).not.toMatch(/^issue-tracker:/m);
@@ -458,23 +401,13 @@ describe("buildSwenyYml — YAML validity", () => {
         const sourceControls = ["github", "gitlab"];
         const observabilities = ["datadog", "sentry", "betterstack", "newrelic", "cloudwatch", null];
         const issueTrackers = ["github-issues", "linear", "jira"];
-        const notifications = ["console", "slack", "discord", "teams", "webhook"];
         for (const sc of sourceControls) {
             for (const obs of observabilities) {
                 for (const it of issueTrackers) {
-                    for (const notif of notifications) {
-                        const yml = buildSwenyYml({
-                            sourceControl: sc,
-                            observability: obs,
-                            issueTracker: it,
-                            notification: notif,
-                            githubAction: false,
-                            cronExpression: null,
-                        });
-                        // Should not throw
-                        const parsed = parseYaml(yml);
-                        expect(parsed["source-control-provider"]).toBe(sc);
-                    }
+                    const yml = buildSwenyYml(sc, obs, it);
+                    // Should not throw
+                    const parsed = parseYaml(yml);
+                    expect(parsed["source-control-provider"]).toBe(sc);
                 }
             }
         }
@@ -662,3 +595,208 @@ describe("collectCredentials — additional cases", () => {
         }
     });
 });
+// ═══════════════════════════════════════════════════════════════════════
+// Workflow-first functions: extractSkillsFromYaml, collectCredentialsForSkills
+// ═══════════════════════════════════════════════════════════════════════
+describe("extractSkillsFromYaml", () => {
+    it("extracts skills from a single node", () => {
+        const yaml = `
+nodes:
+  review:
+    name: Code Review
+    instruction: Review the PR
+    skills: [github]
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual(["github"]);
+    });
+    it("extracts and deduplicates skills from multiple nodes", () => {
+        const yaml = `
+nodes:
+  review:
+    name: Code Review
+    skills: [github, linear]
+  scan:
+    name: Security Scan
+    skills: [github, sentry]
+`;
+        const skills = extractSkillsFromYaml(yaml);
+        expect(skills).toContain("github");
+        expect(skills).toContain("linear");
+        expect(skills).toContain("sentry");
+        expect(skills.filter((s) => s === "github")).toHaveLength(1);
+    });
+    it("returns empty array when no skills present", () => {
+        const yaml = `
+nodes:
+  review:
+    name: Code Review
+    instruction: Review the PR
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual([]);
+    });
+    it("handles skills with spaces around commas", () => {
+        const yaml = `
+nodes:
+  review:
+    skills: [github , linear , sentry]
+`;
+        const skills = extractSkillsFromYaml(yaml);
+        expect(skills).toEqual(["github", "linear", "sentry"]);
+    });
+    it("handles single-skill arrays", () => {
+        const yaml = `
+nodes:
+  review:
+    skills: [datadog]
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual(["datadog"]);
+    });
+});
+describe("collectCredentialsForSkills", () => {
+    it("always includes ANTHROPIC_API_KEY even with no skills", () => {
+        const creds = collectCredentialsForSkills([]);
+        expect(creds.map((c) => c.key)).toEqual(["ANTHROPIC_API_KEY"]);
+    });
+    it("includes credentials for specified skills", () => {
+        const creds = collectCredentialsForSkills(["github", "linear"]);
+        const keys = creds.map((c) => c.key);
+        expect(keys).toContain("ANTHROPIC_API_KEY");
+        expect(keys).toContain("GITHUB_TOKEN");
+        expect(keys).toContain("LINEAR_API_KEY");
+        expect(keys).toContain("LINEAR_TEAM_ID");
+    });
+    it("deduplicates credentials across skills", () => {
+        const creds = collectCredentialsForSkills(["github", "github"]);
+        const tokenCount = creds.filter((c) => c.key === "GITHUB_TOKEN").length;
+        expect(tokenCount).toBe(1);
+    });
+    it("skips unknown skills gracefully", () => {
+        const creds = collectCredentialsForSkills(["github", "nonexistent-skill"]);
+        const keys = creds.map((c) => c.key);
+        expect(keys).toContain("ANTHROPIC_API_KEY");
+        expect(keys).toContain("GITHUB_TOKEN");
+        expect(keys).toHaveLength(2);
+    });
+    it("ANTHROPIC_API_KEY is always first", () => {
+        const creds = collectCredentialsForSkills(["datadog", "github"]);
+        expect(creds[0].key).toBe("ANTHROPIC_API_KEY");
+    });
+});
+// ── extractSkillsFromYaml: block-style arrays + malformed input ───────
+//
+// Regression: an earlier regex-based implementation only matched inline
+// arrays (`skills: [a, b]`). `yaml.stringify()` emits block style by
+// default, so AI-generated `__custom` workflows silently dropped every
+// skill and the wizard then asked for zero credentials. These tests pin
+// the parser-based implementation to handle both forms.
+describe("extractSkillsFromYaml — block-style arrays", () => {
+    it("extracts skills from block-style arrays (yaml.stringify default)", () => {
+        const yaml = `nodes:
+  review:
+    name: Code Review
+    skills:
+      - github
+      - linear
+`;
+        const skills = extractSkillsFromYaml(yaml);
+        expect(skills.sort()).toEqual(["github", "linear"]);
+    });
+    it("deduplicates across block-style nodes", () => {
+        const yaml = `nodes:
+  first:
+    skills:
+      - github
+      - sentry
+  second:
+    skills:
+      - github
+      - linear
+`;
+        const skills = extractSkillsFromYaml(yaml).sort();
+        expect(skills).toEqual(["github", "linear", "sentry"]);
+    });
+    it("handles mixed inline and block-style skills in the same doc", () => {
+        const yaml = `nodes:
+  a:
+    skills: [github, datadog]
+  b:
+    skills:
+      - linear
+      - jira
+`;
+        const skills = extractSkillsFromYaml(yaml).sort();
+        expect(skills).toEqual(["datadog", "github", "jira", "linear"]);
+    });
+    it("ignores non-string skill entries defensively", () => {
+        const yaml = `nodes:
+  review:
+    skills:
+      - github
+      - 42
+      - null
+      - ""
+`;
+        // Only "github" survives the typeof-string + non-empty filter
+        expect(extractSkillsFromYaml(yaml)).toEqual(["github"]);
+    });
+    it("returns empty array for malformed YAML (does not throw)", () => {
+        const yaml = `nodes:
+  review:
+    skills: [github, linear
+    # unclosed bracket above — invalid yaml
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual([]);
+    });
+    it("returns empty array for YAML with no nodes key", () => {
+        expect(extractSkillsFromYaml("foo: bar\n")).toEqual([]);
+    });
+    it("returns empty array for empty/whitespace input", () => {
+        expect(extractSkillsFromYaml("")).toEqual([]);
+        expect(extractSkillsFromYaml("   \n")).toEqual([]);
+    });
+    it("returns empty array when nodes entries have no skills field", () => {
+        const yaml = `nodes:
+  review:
+    name: Code Review
+    instruction: Review the PR
+`;
+        expect(extractSkillsFromYaml(yaml)).toEqual([]);
+    });
+});
+// ── Deprecated alias: runInit === runNew ──────────────────────────────
+describe("runInit deprecation alias", () => {
+    it("re-exports runNew as runInit (identity pin)", () => {
+        // Callers using `import { runInit } from "@sweny-ai/core/new"` must
+        // continue to hit the same function during the deprecation window.
+        expect(runInit).toBe(runNew);
+    });
+});
+describe("SKILL_CREDENTIALS", () => {
+    it("has entries for all built-in skills", () => {
+        const expected = [
+            "github",
+            "gitlab",
+            "datadog",
+            "sentry",
+            "betterstack",
+            "newrelic",
+            "linear",
+            "jira",
+            "slack",
+            "discord",
+            "notification",
+        ];
+        for (const skill of expected) {
+            expect(SKILL_CREDENTIALS).toHaveProperty(skill);
+        }
+    });
+    it("every skill has valid credential entries", () => {
+        for (const [skill, creds] of Object.entries(SKILL_CREDENTIALS)) {
+            expect(Array.isArray(creds), `${skill} should have an array`).toBe(true);
+            for (const cred of creds) {
+                expect(typeof cred.key, `${skill}.${cred.key} should be a string`).toBe("string");
+                expect(cred.key, `${skill}.${cred.key} should be UPPER_SNAKE_CASE`).toMatch(/^[A-Z][A-Z0-9_]+$/);
+            }
+        }
+    });
+});

package/dist/cli/publish.d.ts

@@ -0,0 +1,34 @@
+/**
+ * sweny publish — Interactive CLI for publishing workflows and skills to the marketplace.
+ *
+ * Supports:
+ * - Workflow YAML files → marketplace community submission
+ * - Skill directories (SKILL.md) → marketplace skill submission
+ * - Three output modes: GitHub PR (via `gh`), copy to clipboard, save locally
+ */
+import type { Command } from "commander";
+export interface PublishResult {
+    type: "workflow" | "skill";
+    id: string;
+    name: string;
+    outputPath?: string;
+    prUrl?: string;
+}
+export declare function validateWorkflowFile(filePath: string): {
+    valid: boolean;
+    id?: string;
+    name?: string;
+    nodeCount?: number;
+    edgeCount?: number;
+    errors: string[];
+};
+export declare function validateSkillDir(dirPath: string): {
+    valid: boolean;
+    id?: string;
+    name?: string;
+    hasInstruction: boolean;
+    hasMcp: boolean;
+    errors: string[];
+};
+export declare function runPublish(): Promise<PublishResult | null>;
+export declare function registerPublishCommand(program: Command): void;