@sweny-ai/core 0.1.30 → 0.1.31

package/dist/cli/init.d.ts

@@ -0,0 +1,53 @@
+/**
+ * sweny init — Interactive setup wizard
+ *
+ * Pure functions for file generation + thin @clack/prompts interactive layer.
+ * Tests cover the pure functions; the interactive wizard is thin glue.
+ */
+export interface Credential {
+    key: string;
+    hint?: string;
+    url?: string;
+    default?: string;
+}
+export interface InitSelections {
+    sourceControl: string;
+    observability: string | null;
+    issueTracker: string;
+    notification: string;
+    githubAction: boolean;
+    cronExpression: string | null;
+}
+export interface GitRemoteInfo {
+    provider: "github" | "gitlab";
+    remote: string;
+}
+export declare const PROVIDER_CREDENTIALS: Record<string, Credential[]>;
+/**
+ * Gather all unique credentials required for the selected providers.
+ * Always includes ANTHROPIC_API_KEY. Deduplicates by key name.
+ */
+export declare function collectCredentials(selections: InitSelections): Credential[];
+/**
+ * Detect the git remote origin from `.git/config`.
+ * Returns provider + normalised remote (e.g. "github.com/owner/repo"), or null.
+ */
+export declare function detectGitRemote(cwd: string): GitRemoteInfo | null;
+/**
+ * Generate .sweny.yml content from selections.
+ */
+export declare function buildSwenyYml(selections: InitSelections): string;
+/**
+ * Generate .env template with comments for each credential.
+ */
+export declare function buildEnvTemplate(credentials: Credential[]): string;
+/**
+ * Generate a GitHub Actions workflow YAML for SWEny.
+ * Only includes credentials WITHOUT defaults as secrets.
+ */
+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.
+ */
+export declare function runInit(): Promise<void>;

package/dist/cli/init.js

@@ -0,0 +1,521 @@
+/**
+ * sweny init — Interactive setup wizard
+ *
+ * Pure functions for file generation + thin @clack/prompts interactive layer.
+ * Tests cover the pure functions; the interactive wizard is thin glue.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as p from "@clack/prompts";
+import chalk from "chalk";
+// ── Credential table ───────────────────────────────────────────────────
+export const PROVIDER_CREDENTIALS = {
+    github: [
+        {
+            key: "GITHUB_TOKEN",
+            url: "https://github.com/settings/tokens",
+            hint: "repo + issues scopes",
+        },
+    ],
+    gitlab: [
+        {
+            key: "GITLAB_TOKEN",
+            hint: "api scope",
+            url: "https://gitlab.com/-/profile/personal_access_tokens",
+        },
+        { key: "GITLAB_URL", hint: "e.g. https://gitlab.com", default: "https://gitlab.com" },
+    ],
+    datadog: [
+        {
+            key: "DD_API_KEY",
+            url: "https://app.datadoghq.com/organization-settings",
+            hint: "Organization Settings > API Keys",
+        },
+        { key: "DD_APP_KEY", hint: "Organization Settings > Application Keys" },
+        { key: "DD_SITE", hint: "datadoghq.com, datadoghq.eu, etc.", default: "datadoghq.com" },
+    ],
+    sentry: [
+        {
+            key: "SENTRY_AUTH_TOKEN",
+            url: "https://sentry.io/settings/auth-tokens/",
+        },
+        { key: "SENTRY_ORG", hint: "sentry.io/organizations/slug/" },
+    ],
+    betterstack: [
+        {
+            key: "BETTERSTACK_API_TOKEN",
+            url: "https://betterstack.com/docs/logs/api",
+        },
+    ],
+    newrelic: [{ key: "NR_API_KEY", url: "https://one.newrelic.com/api-keys" }],
+    cloudwatch: [
+        { key: "AWS_ACCESS_KEY_ID", hint: "IAM user access key" },
+        { key: "AWS_SECRET_ACCESS_KEY", hint: "IAM user secret key" },
+        { key: "AWS_REGION", hint: "e.g. us-east-1", default: "us-east-1" },
+    ],
+    "github-issues": [],
+    linear: [
+        {
+            key: "LINEAR_API_KEY",
+            url: "https://linear.app/settings/api",
+        },
+        {
+            key: "LINEAR_TEAM_ID",
+            hint: "Settings > Teams > copy ID from URL",
+        },
+    ],
+    jira: [
+        { key: "JIRA_BASE_URL", hint: "e.g. https://your-org.atlassian.net" },
+        { key: "JIRA_EMAIL", hint: "your Atlassian account email" },
+        {
+            key: "JIRA_API_TOKEN",
+            url: "https://id.atlassian.com/manage-profile/security/api-tokens",
+        },
+    ],
+    console: [],
+    slack: [{ key: "SLACK_BOT_TOKEN", url: "https://api.slack.com/apps" }],
+    discord: [{ key: "DISCORD_WEBHOOK_URL", hint: "Server Settings > Integrations > Webhooks" }],
+    teams: [{ key: "TEAMS_WEBHOOK_URL", hint: "Channel > Connectors > Incoming Webhook" }],
+    webhook: [{ key: "NOTIFICATION_WEBHOOK_URL", hint: "Your webhook endpoint URL" }],
+};
+const ALWAYS_CREDENTIALS = [
+    {
+        key: "ANTHROPIC_API_KEY",
+        url: "https://console.anthropic.com/settings/api-keys",
+        hint: "Claude API key",
+    },
+];
+// ── Functions ──────────────────────────────────────────────────────────
+/**
+ * Gather all unique credentials required for the selected providers.
+ * Always includes ANTHROPIC_API_KEY. Deduplicates by key name.
+ */
+export function collectCredentials(selections) {
+    const seen = new Map();
+    // Always-present credentials first
+    for (const cred of ALWAYS_CREDENTIALS) {
+        seen.set(cred.key, cred);
+    }
+    const providers = [
+        selections.sourceControl,
+        selections.observability,
+        selections.issueTracker,
+        selections.notification,
+    ].filter((p) => p !== null);
+    for (const provider of providers) {
+        const creds = PROVIDER_CREDENTIALS[provider];
+        if (!creds)
+            continue;
+        for (const cred of creds) {
+            if (!seen.has(cred.key)) {
+                seen.set(cred.key, cred);
+            }
+        }
+    }
+    return Array.from(seen.values());
+}
+/**
+ * Detect the git remote origin from `.git/config`.
+ * Returns provider + normalised remote (e.g. "github.com/owner/repo"), or null.
+ */
+export function detectGitRemote(cwd) {
+    const configPath = path.join(cwd, ".git", "config");
+    let content;
+    try {
+        content = fs.readFileSync(configPath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    // Find [remote "origin"] section and extract url
+    const remoteMatch = content.match(/\[remote\s+"origin"\]\s*\n(?:\s+[^\[]*?\n)*?\s*url\s*=\s*(.+)/);
+    if (!remoteMatch)
+        return null;
+    const url = remoteMatch[1].trim();
+    // SSH: git@github.com:owner/repo.git
+    const sshMatch = url.match(/^git@([^:]+):(.+?)(?:\.git)?$/);
+    if (sshMatch) {
+        const host = sshMatch[1];
+        const repoPath = sshMatch[2];
+        if (host === "github.com") {
+            return { provider: "github", remote: `github.com/${repoPath}` };
+        }
+        if (host === "gitlab.com") {
+            return { provider: "gitlab", remote: `gitlab.com/${repoPath}` };
+        }
+        return null;
+    }
+    // SSH scheme: ssh://git@github.com/owner/repo.git
+    const sshSchemeMatch = url.match(/^ssh:\/\/git@([^/]+)\/(.+?)(?:\.git)?$/);
+    if (sshSchemeMatch) {
+        const host = sshSchemeMatch[1];
+        const repoPath = sshSchemeMatch[2];
+        if (host === "github.com") {
+            return { provider: "github", remote: `github.com/${repoPath}` };
+        }
+        if (host === "gitlab.com") {
+            return { provider: "gitlab", remote: `gitlab.com/${repoPath}` };
+        }
+        return null;
+    }
+    // HTTPS: https://github.com/owner/repo.git
+    const httpsMatch = url.match(/^https?:\/\/([^/]+)\/(.+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        const host = httpsMatch[1];
+        const repoPath = httpsMatch[2];
+        if (host === "github.com") {
+            return { provider: "github", remote: `github.com/${repoPath}` };
+        }
+        if (host === "gitlab.com") {
+            return { provider: "gitlab", remote: `gitlab.com/${repoPath}` };
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * Generate .sweny.yml content from selections.
+ */
+export function buildSwenyYml(selections) {
+    const lines = [];
+    lines.push("# .sweny.yml — SWEny project configuration");
+    lines.push("# Secrets (API keys, tokens) go in .env (gitignored).");
+    lines.push("# Docs: https://docs.sweny.ai/cli");
+    lines.push("");
+    lines.push(`source-control-provider: ${selections.sourceControl}`);
+    if (selections.observability !== null) {
+        lines.push(`observability-provider: ${selections.observability}`);
+    }
+    lines.push(`issue-tracker-provider: ${selections.issueTracker}`);
+    // Omit notification-provider when "console" (it's the default)
+    if (selections.notification !== "console") {
+        lines.push(`notification-provider: ${selections.notification}`);
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+/**
+ * Generate .env template with comments for each credential.
+ */
+export function buildEnvTemplate(credentials) {
+    const lines = [];
+    lines.push("# .env — SWEny credentials (DO NOT COMMIT)");
+    lines.push("# Fill in each value, then run: sweny check");
+    lines.push("");
+    for (const cred of credentials) {
+        if (cred.url) {
+            lines.push(`# ${cred.url}`);
+        }
+        if (cred.hint) {
+            lines.push(`# ${cred.hint}`);
+        }
+        if (cred.default !== undefined) {
+            lines.push(`${cred.key}=${cred.default}`);
+        }
+        else {
+            lines.push(`${cred.key}=`);
+        }
+        lines.push("");
+    }
+    return lines.join("\n");
+}
+/**
+ * Generate a GitHub Actions workflow YAML for SWEny.
+ * Only includes credentials WITHOUT defaults as secrets.
+ */
+export function buildActionWorkflow(credentials, cronExpression) {
+    const secretCreds = credentials.filter((c) => c.default === undefined);
+    const lines = [];
+    lines.push("name: SWEny Triage");
+    lines.push("");
+    lines.push("on:");
+    lines.push("  schedule:");
+    lines.push(`    - cron: "${cronExpression}"`);
+    lines.push("  workflow_dispatch:");
+    lines.push("");
+    lines.push("jobs:");
+    lines.push("  triage:");
+    lines.push("    runs-on: ubuntu-latest");
+    lines.push("    steps:");
+    lines.push("      - uses: actions/checkout@v4");
+    lines.push("      - uses: swenyai/sweny@v4");
+    lines.push("        with:");
+    lines.push("          workflow: triage");
+    if (secretCreds.length > 0) {
+        lines.push("        env:");
+        for (const cred of secretCreds) {
+            lines.push(`          ${cred.key}: \${{ secrets.${cred.key} }}`);
+        }
+    }
+    lines.push("");
+    return lines.join("\n");
+}
+// ── Interactive wizard ────────────────────────────────────────────────
+function cancel() {
+    p.cancel("Setup cancelled.");
+    process.exit(0);
+}
+/**
+ * Interactive setup wizard — prompts the user through provider selection,
+ * then generates `.sweny.yml`, `.env`, and an optional GitHub Action workflow.
+ */
+export async function runInit() {
+    const cwd = process.cwd();
+    // ── Intro ───────────────────────────────────────────────────────────
+    p.intro("Let's set up SWEny");
+    const gitInfo = detectGitRemote(cwd);
+    if (gitInfo) {
+        p.log.info(`Detected git remote: ${chalk.cyan(gitInfo.remote)}`);
+    }
+    // ── Existing file check ─────────────────────────────────────────────
+    const configPath = path.join(cwd, ".sweny.yml");
+    if (fs.existsSync(configPath)) {
+        const overwrite = await p.confirm({
+            message: ".sweny.yml already exists. Overwrite?",
+            initialValue: false,
+        });
+        if (p.isCancel(overwrite))
+            cancel();
+        if (!overwrite) {
+            p.cancel("Setup cancelled — existing config preserved.");
+            process.exit(0);
+        }
+    }
+    // ── Screen 1: Source control ────────────────────────────────────────
+    const sourceControl = await p.select({
+        message: "Source control provider",
+        initialValue: gitInfo?.provider ?? "github",
+        options: [
+            {
+                value: "github",
+                label: "GitHub" + (gitInfo?.provider === "github" ? " (detected)" : ""),
+            },
+            {
+                value: "gitlab",
+                label: "GitLab" + (gitInfo?.provider === "gitlab" ? " (detected)" : ""),
+            },
+        ],
+    });
+    if (p.isCancel(sourceControl))
+        cancel();
+    // ── Screen 2: Observability ─────────────────────────────────────────
+    const obsRaw = await p.select({
+        message: "Observability provider",
+        options: [
+            { value: "datadog", label: "Datadog" },
+            { value: "sentry", label: "Sentry" },
+            { value: "betterstack", label: "BetterStack" },
+            { value: "newrelic", label: "New Relic" },
+            { value: "cloudwatch", label: "CloudWatch" },
+            { value: "__other", label: "Other" },
+            { value: "__none", label: "None" },
+        ],
+    });
+    if (p.isCancel(obsRaw))
+        cancel();
+    let observability;
+    if (obsRaw === "__none") {
+        observability = null;
+    }
+    else if (obsRaw === "__other") {
+        const custom = await p.text({
+            message: "Enter your observability provider name",
+            validate: (v) => {
+                if (!v || v.trim().length === 0)
+                    return "Provider name is required";
+                if (!/^[a-z0-9-]+$/.test(v.trim()))
+                    return "Provider name must be lowercase letters, numbers, and hyphens only";
+                return undefined;
+            },
+        });
+        if (p.isCancel(custom))
+            cancel();
+        observability = custom.trim().toLowerCase();
+    }
+    else {
+        observability = obsRaw;
+    }
+    // ── Screen 3: Issue tracker ─────────────────────────────────────────
+    const issueTracker = await p.select({
+        message: "Issue tracker",
+        initialValue: sourceControl === "github" ? "github-issues" : undefined,
+        options: [
+            { value: "github-issues", label: "GitHub Issues" },
+            { value: "linear", label: "Linear" },
+            { value: "jira", label: "Jira" },
+        ],
+    });
+    if (p.isCancel(issueTracker))
+        cancel();
+    // ── Screen 4: Notification ──────────────────────────────────────────
+    const notification = await p.select({
+        message: "Notification channel",
+        initialValue: "console",
+        options: [
+            { value: "console", label: "Console (default)" },
+            { value: "slack", label: "Slack" },
+            { value: "discord", label: "Discord" },
+            { value: "teams", label: "Microsoft Teams" },
+            { value: "webhook", label: "Webhook" },
+        ],
+    });
+    if (p.isCancel(notification))
+        cancel();
+    // ── Screen 5: GitHub Action ─────────────────────────────────────────
+    const wantAction = await p.confirm({
+        message: "Set up a GitHub Action workflow?",
+        initialValue: true,
+    });
+    if (p.isCancel(wantAction))
+        cancel();
+    let cronExpression = null;
+    if (wantAction) {
+        const schedule = await p.select({
+            message: "How often should the triage run?",
+            options: [
+                { value: "0 9 * * *", label: "Daily (9 AM UTC)" },
+                { value: "0 9 * * 1", label: "Weekly (Monday 9 AM UTC)" },
+                { value: "__custom", label: "Custom cron expression" },
+            ],
+        });
+        if (p.isCancel(schedule))
+            cancel();
+        if (schedule === "__custom") {
+            const customCron = await p.text({
+                message: "Enter cron expression (e.g. 0 8 * * 1-5)",
+                validate: (v) => {
+                    if (!v || v.trim().length === 0)
+                        return "Cron expression is required";
+                    if (!/^[\d*,\/-]+(\s+[\d*,\/-]+){4}$/.test(v.trim()))
+                        return "Must be a valid 5-field cron expression";
+                    return undefined;
+                },
+            });
+            if (p.isCancel(customCron))
+                cancel();
+            cronExpression = customCron.trim();
+        }
+        else {
+            cronExpression = schedule;
+        }
+    }
+    // ── Assemble selections ─────────────────────────────────────────────
+    const selections = {
+        sourceControl: sourceControl,
+        observability,
+        issueTracker: issueTracker,
+        notification: notification,
+        githubAction: !!wantAction,
+        cronExpression,
+    };
+    const credentials = collectCredentials(selections);
+    // ── Screen 6: Summary ───────────────────────────────────────────────
+    const files = [".sweny.yml", ".env"];
+    if (selections.githubAction)
+        files.push(".github/workflows/sweny.yml");
+    p.log.message([
+        chalk.bold("Files to create:"),
+        ...files.map((f) => `  ${chalk.cyan(f)}`),
+        "",
+        chalk.bold("Providers:"),
+        `  Source control:  ${selections.sourceControl}`,
+        `  Observability:   ${selections.observability ?? "none"}`,
+        `  Issue tracker:   ${selections.issueTracker}`,
+        `  Notification:    ${selections.notification}`,
+        selections.githubAction ? `  GitHub Action:   ${selections.cronExpression}` : "  GitHub Action:   no",
+    ].join("\n"));
+    const confirmed = await p.confirm({
+        message: "Create these files?",
+        initialValue: true,
+    });
+    if (p.isCancel(confirmed))
+        cancel();
+    if (!confirmed) {
+        p.cancel("Setup cancelled.");
+        process.exit(0);
+    }
+    // ── Screen 7: Write files ──────────────────────────────────────────
+    // 1. Write .sweny.yml
+    fs.writeFileSync(configPath, buildSwenyYml(selections), "utf-8");
+    p.log.success("Created .sweny.yml");
+    // 2. Write .env
+    const envPath = path.join(cwd, ".env");
+    if (fs.existsSync(envPath)) {
+        const existing = fs.readFileSync(envPath, "utf-8");
+        // Parse defined keys (ignore comment lines)
+        const definedKeys = new Set(existing
+            .split("\n")
+            .filter((l) => !l.trimStart().startsWith("#") && l.includes("="))
+            .map((l) => l.split("=")[0].trim()));
+        const newKeys = [];
+        for (const cred of credentials) {
+            if (!definedKeys.has(cred.key)) {
+                newKeys.push(cred);
+            }
+        }
+        if (newKeys.length > 0) {
+            const appendBlock = "\n" + buildEnvTemplate(newKeys);
+            fs.appendFileSync(envPath, appendBlock, "utf-8");
+            p.log.success(`Appended ${newKeys.length} new key(s) to .env`);
+        }
+        else {
+            p.log.info(".env already contains all required keys — skipped");
+        }
+    }
+    else {
+        fs.writeFileSync(envPath, buildEnvTemplate(credentials), "utf-8");
+        p.log.success("Created .env");
+    }
+    // 3. GitHub Action workflow
+    if (selections.githubAction && selections.cronExpression) {
+        const workflowDir = path.join(cwd, ".github", "workflows");
+        const workflowPath = path.join(workflowDir, "sweny.yml");
+        if (fs.existsSync(workflowPath)) {
+            const overwriteWf = await p.confirm({
+                message: ".github/workflows/sweny.yml already exists. Overwrite?",
+                initialValue: false,
+            });
+            if (p.isCancel(overwriteWf))
+                cancel();
+            if (!overwriteWf) {
+                p.log.info("Skipped GitHub Action workflow");
+            }
+            else {
+                fs.mkdirSync(workflowDir, { recursive: true });
+                fs.writeFileSync(workflowPath, buildActionWorkflow(credentials, selections.cronExpression), "utf-8");
+                p.log.success("Created .github/workflows/sweny.yml");
+            }
+        }
+        else {
+            fs.mkdirSync(workflowDir, { recursive: true });
+            fs.writeFileSync(workflowPath, buildActionWorkflow(credentials, selections.cronExpression), "utf-8");
+            p.log.success("Created .github/workflows/sweny.yml");
+        }
+    }
+    // 4. .gitignore check
+    const gitignorePath = path.join(cwd, ".gitignore");
+    if (fs.existsSync(gitignorePath)) {
+        const gitignore = fs.readFileSync(gitignorePath, "utf-8");
+        const envIgnored = gitignore.split("\n").some((line) => line.trim() === ".env");
+        if (!envIgnored) {
+            p.log.warn(chalk.yellow(".env is not in .gitignore — add it to avoid committing secrets"));
+        }
+    }
+    else {
+        p.log.warn(chalk.yellow("No .gitignore found — make sure .env is not committed"));
+    }
+    // 5. Next steps
+    const docUrls = credentials.filter((c) => c.url).map((c) => `  ${c.key}: ${c.url}`);
+    p.note([
+        "1. Fill in your API keys in .env:",
+        ...docUrls,
+        "",
+        "2. Verify connectivity:",
+        "   sweny check",
+        "",
+        "3. Run a dry-run triage:",
+        "   sweny triage --dry-run",
+    ].join("\n"), "Next steps");
+    // 6. Done
+    p.outro("You're all set!");
+}

package/dist/cli/init.test.d.ts

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

package/dist/cli/init.test.js

@@ -0,0 +1,664 @@
+import { describe, it, expect, afterEach } from "vitest";
+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";
+// ── detectGitRemote ────────────────────────────────────────────────────
+describe("detectGitRemote", () => {
+    const tmpDirs = [];
+    function makeTempRepo(gitConfigContent) {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-init-test-"));
+        tmpDirs.push(dir);
+        const gitDir = path.join(dir, ".git");
+        fs.mkdirSync(gitDir, { recursive: true });
+        fs.writeFileSync(path.join(gitDir, "config"), gitConfigContent);
+        return dir;
+    }
+    afterEach(() => {
+        for (const d of tmpDirs) {
+            fs.rmSync(d, { recursive: true, force: true });
+        }
+        tmpDirs.length = 0;
+    });
+    it("detects GitHub HTTPS remote", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = https://github.com/acme/widgets.git
+\tfetch = +refs/heads/*:refs/remotes/origin/*
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "github",
+            remote: "github.com/acme/widgets",
+        });
+    });
+    it("detects GitHub SSH remote", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = git@github.com:acme/widgets.git
+\tfetch = +refs/heads/*:refs/remotes/origin/*
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "github",
+            remote: "github.com/acme/widgets",
+        });
+    });
+    it("detects GitLab HTTPS remote", () => {
+        const cwd = makeTempRepo(`
+[core]
+\tbare = false
+[remote "origin"]
+\turl = https://gitlab.com/team/project.git
+\tfetch = +refs/heads/*:refs/remotes/origin/*
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "gitlab",
+            remote: "gitlab.com/team/project",
+        });
+    });
+    it("returns null when no .git directory exists", () => {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-init-test-"));
+        tmpDirs.push(dir);
+        expect(detectGitRemote(dir)).toBeNull();
+    });
+    it("returns null for unknown host (bitbucket)", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = git@bitbucket.org:acme/widgets.git
+`);
+        expect(detectGitRemote(cwd)).toBeNull();
+    });
+    it("handles HTTPS URLs without .git suffix", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = https://github.com/acme/widgets
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "github",
+            remote: "github.com/acme/widgets",
+        });
+    });
+});
+// ── collectCredentials ─────────────────────────────────────────────────
+describe("collectCredentials", () => {
+    it("always includes ANTHROPIC_API_KEY", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        expect(creds.map((c) => c.key)).toContain("ANTHROPIC_API_KEY");
+    });
+    it("includes provider-specific credentials", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "datadog",
+            issueTracker: "linear",
+            notification: "slack",
+            githubAction: true,
+            cronExpression: "0 8 * * 1",
+        });
+        const keys = creds.map((c) => c.key);
+        expect(keys).toContain("GITHUB_TOKEN");
+        expect(keys).toContain("DD_API_KEY");
+        expect(keys).toContain("DD_APP_KEY");
+        expect(keys).toContain("DD_SITE");
+        expect(keys).toContain("LINEAR_API_KEY");
+        expect(keys).toContain("LINEAR_TEAM_ID");
+        expect(keys).toContain("SLACK_BOT_TOKEN");
+    });
+    it("deduplicates credentials (github + github-issues)", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        const keys = creds.map((c) => c.key);
+        const githubTokenCount = keys.filter((k) => k === "GITHUB_TOKEN").length;
+        expect(githubTokenCount).toBe(1);
+    });
+    it("handles empty credential providers (console, github-issues)", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        expect(creds).toHaveLength(2);
+    });
+});
+// ── PROVIDER_CREDENTIALS table sanity ──────────────────────────────────
+describe("PROVIDER_CREDENTIALS", () => {
+    it("has entries for all expected providers", () => {
+        const expected = [
+            "github",
+            "gitlab",
+            "datadog",
+            "sentry",
+            "betterstack",
+            "newrelic",
+            "cloudwatch",
+            "github-issues",
+            "linear",
+            "jira",
+            "console",
+            "slack",
+            "discord",
+            "teams",
+            "webhook",
+        ];
+        for (const name of expected) {
+            expect(PROVIDER_CREDENTIALS).toHaveProperty(name);
+        }
+    });
+    it("github-issues and console have empty credential arrays", () => {
+        expect(PROVIDER_CREDENTIALS["github-issues"]).toEqual([]);
+        expect(PROVIDER_CREDENTIALS["console"]).toEqual([]);
+    });
+});
+// ── 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",
+        });
+        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,
+        });
+        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,
+        });
+        expect(yml).toContain("# .sweny.yml");
+    });
+});
+// ── buildEnvTemplate ───────────────────────────────────────────────────
+describe("buildEnvTemplate", () => {
+    it("includes url and hint comments", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        const template = buildEnvTemplate(creds);
+        expect(template).toContain("# https://console.anthropic.com/settings/api-keys");
+        expect(template).toContain("# Claude API key");
+        expect(template).toContain("ANTHROPIC_API_KEY=");
+        expect(template).toContain("# https://github.com/settings/tokens");
+        expect(template).toContain("# repo + issues scopes");
+        expect(template).toContain("GITHUB_TOKEN=");
+    });
+    it("pre-fills defaults", () => {
+        const creds = collectCredentials({
+            sourceControl: "gitlab",
+            observability: "datadog",
+            issueTracker: "jira",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        const template = buildEnvTemplate(creds);
+        expect(template).toContain("GITLAB_URL=https://gitlab.com");
+        expect(template).toContain("DD_SITE=datadoghq.com");
+    });
+    it("includes header comment", () => {
+        const template = buildEnvTemplate([]);
+        expect(template).toContain("# .env");
+    });
+});
+// ── buildActionWorkflow ────────────────────────────────────────────────
+describe("buildActionWorkflow", () => {
+    it("generates a valid workflow with weekly cron", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: true,
+            cronExpression: "0 8 * * 1",
+        });
+        const workflow = buildActionWorkflow(creds, "0 8 * * 1");
+        expect(workflow).toContain("name: SWEny Triage");
+        expect(workflow).toContain('cron: "0 8 * * 1"');
+        expect(workflow).toContain("workflow_dispatch:");
+        expect(workflow).toContain("actions/checkout@v4");
+        expect(workflow).toContain("swenyai/sweny@v4");
+    });
+    it("generates a workflow with daily cron", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "sentry",
+            issueTracker: "linear",
+            notification: "slack",
+            githubAction: true,
+            cronExpression: "0 9 * * *",
+        });
+        const workflow = buildActionWorkflow(creds, "0 9 * * *");
+        expect(workflow).toContain('cron: "0 9 * * *"');
+    });
+    it("skips credentials with defaults from secrets", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "datadog",
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: true,
+            cronExpression: "0 8 * * 1",
+        });
+        const workflow = buildActionWorkflow(creds, "0 8 * * 1");
+        // DD_SITE has a default, so it should NOT appear in secrets
+        expect(workflow).not.toContain("secrets.DD_SITE");
+        // DD_API_KEY has no default, so it should appear
+        expect(workflow).toContain("secrets.DD_API_KEY");
+        expect(workflow).toContain("secrets.DD_APP_KEY");
+        expect(workflow).toContain("secrets.ANTHROPIC_API_KEY");
+        expect(workflow).toContain("secrets.GITHUB_TOKEN");
+    });
+    it("maps credentials to ${{ secrets.KEY }} format", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "linear",
+            notification: "slack",
+            githubAction: true,
+            cronExpression: "0 8 * * 1",
+        });
+        const workflow = buildActionWorkflow(creds, "0 8 * * 1");
+        expect(workflow).toContain("ANTHROPIC_API_KEY: ${{ secrets.ANTHROPIC_API_KEY }}");
+        expect(workflow).toContain("GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}");
+        expect(workflow).toContain("LINEAR_API_KEY: ${{ secrets.LINEAR_API_KEY }}");
+        expect(workflow).toContain("SLACK_BOT_TOKEN: ${{ secrets.SLACK_BOT_TOKEN }}");
+    });
+});
+// ═══════════════════════════════════════════════════════════════════════
+// Additional tests: edge cases, correctness, security
+// ═══════════════════════════════════════════════════════════════════════
+// ── detectGitRemote: additional edge cases ────────────────────────────
+describe("detectGitRemote — edge cases", () => {
+    const tmpDirs = [];
+    function makeTempRepo(gitConfigContent) {
+        const dir = fs.mkdtempSync(path.join(os.tmpdir(), "sweny-init-test-"));
+        tmpDirs.push(dir);
+        const gitDir = path.join(dir, ".git");
+        fs.mkdirSync(gitDir, { recursive: true });
+        fs.writeFileSync(path.join(gitDir, "config"), gitConfigContent);
+        return dir;
+    }
+    afterEach(() => {
+        for (const d of tmpDirs) {
+            fs.rmSync(d, { recursive: true, force: true });
+        }
+        tmpDirs.length = 0;
+    });
+    it("detects ssh:// scheme GitHub remote", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = ssh://git@github.com/acme/widgets.git
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "github",
+            remote: "github.com/acme/widgets",
+        });
+    });
+    it("detects ssh:// scheme GitLab remote", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = ssh://git@gitlab.com/team/project.git
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "gitlab",
+            remote: "gitlab.com/team/project",
+        });
+    });
+    it("returns null for ssh:// with unknown host", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = ssh://git@bitbucket.org/acme/widgets.git
+`);
+        expect(detectGitRemote(cwd)).toBeNull();
+    });
+    it("handles git config with multiple remotes (uses origin)", () => {
+        const cwd = makeTempRepo(`
+[remote "upstream"]
+\turl = https://gitlab.com/upstream/project.git
+[remote "origin"]
+\turl = https://github.com/acme/widgets.git
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "github",
+            remote: "github.com/acme/widgets",
+        });
+    });
+    it("handles nested org paths (gitlab subgroups)", () => {
+        const cwd = makeTempRepo(`
+[remote "origin"]
+\turl = https://gitlab.com/org/team/subteam/project.git
+`);
+        const info = detectGitRemote(cwd);
+        expect(info).toEqual({
+            provider: "gitlab",
+            remote: "gitlab.com/org/team/subteam/project",
+        });
+    });
+    it("handles empty git config file", () => {
+        const cwd = makeTempRepo("");
+        expect(detectGitRemote(cwd)).toBeNull();
+    });
+    it("handles git config with no origin remote", () => {
+        const cwd = makeTempRepo(`
+[remote "upstream"]
+\turl = https://github.com/acme/widgets.git
+`);
+        expect(detectGitRemote(cwd)).toBeNull();
+    });
+});
+// ── 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 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 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,
+        });
+        // 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);
+    });
+    it("every provider combination produces valid YAML", () => {
+        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);
+                    }
+                }
+            }
+        }
+    });
+});
+// ── buildEnvTemplate: correctness ─────────────────────────────────────
+describe("buildEnvTemplate — correctness", () => {
+    it("every credential has exactly one KEY= line", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "datadog",
+            issueTracker: "linear",
+            notification: "slack",
+            githubAction: false,
+            cronExpression: null,
+        });
+        const template = buildEnvTemplate(creds);
+        for (const cred of creds) {
+            const matches = template.match(new RegExp(`^${cred.key}=`, "gm"));
+            expect(matches, `${cred.key} should appear exactly once`).toHaveLength(1);
+        }
+    });
+    it("does not include empty KEY= lines for credentials with defaults", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "datadog",
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        const template = buildEnvTemplate(creds);
+        // DD_SITE has a default — should be pre-filled, not empty
+        expect(template).toContain("DD_SITE=datadoghq.com");
+        expect(template).not.toMatch(/^DD_SITE=$/m);
+    });
+    it("header warns about not committing", () => {
+        const template = buildEnvTemplate([]);
+        expect(template).toContain("DO NOT COMMIT");
+    });
+    it("header mentions sweny check", () => {
+        const template = buildEnvTemplate([]);
+        expect(template).toContain("sweny check");
+    });
+});
+// ── buildActionWorkflow: YAML validity ────────────────────────────────
+describe("buildActionWorkflow — YAML validity", () => {
+    it("generates valid GitHub Actions YAML", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "datadog",
+            issueTracker: "linear",
+            notification: "console",
+            githubAction: true,
+            cronExpression: "0 9 * * 1",
+        });
+        const workflow = buildActionWorkflow(creds, "0 9 * * 1");
+        const parsed = parseYaml(workflow);
+        expect(parsed.name).toBe("SWEny Triage");
+        expect(parsed.on.schedule[0].cron).toBe("0 9 * * 1");
+        expect(parsed.on.workflow_dispatch).toBeDefined();
+        expect(parsed.jobs.triage["runs-on"]).toBe("ubuntu-latest");
+    });
+    it("includes with.workflow: triage", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: true,
+            cronExpression: "0 9 * * 1",
+        });
+        const workflow = buildActionWorkflow(creds, "0 9 * * 1");
+        expect(workflow).toContain("workflow: triage");
+    });
+    it("omits env block when all credentials have defaults", () => {
+        // Only credentials with defaults — should produce no env block
+        const workflow = buildActionWorkflow([
+            { key: "DD_SITE", default: "datadoghq.com" },
+            { key: "AWS_REGION", default: "us-east-1" },
+        ], "0 9 * * 1");
+        expect(workflow).not.toContain("env:");
+    });
+    it("generates valid YAML for every provider combination", () => {
+        const combos = [
+            {
+                sourceControl: "github",
+                observability: "datadog",
+                issueTracker: "linear",
+                notification: "slack",
+                githubAction: true,
+                cronExpression: "0 9 * * 1",
+            },
+            {
+                sourceControl: "gitlab",
+                observability: "sentry",
+                issueTracker: "jira",
+                notification: "teams",
+                githubAction: true,
+                cronExpression: "0 9 * * *",
+            },
+            {
+                sourceControl: "github",
+                observability: "cloudwatch",
+                issueTracker: "github-issues",
+                notification: "discord",
+                githubAction: true,
+                cronExpression: "0 8 * * 1-5",
+            },
+            {
+                sourceControl: "github",
+                observability: null,
+                issueTracker: "github-issues",
+                notification: "console",
+                githubAction: true,
+                cronExpression: "0 9 * * 1",
+            },
+        ];
+        for (const sel of combos) {
+            const creds = collectCredentials(sel);
+            const workflow = buildActionWorkflow(creds, sel.cronExpression);
+            // Should not throw
+            const parsed = parseYaml(workflow);
+            expect(parsed.name).toBe("SWEny Triage");
+            expect(parsed.jobs.triage).toBeDefined();
+        }
+    });
+});
+// ── collectCredentials: additional cases ──────────────────────────────
+describe("collectCredentials — additional cases", () => {
+    it("ANTHROPIC_API_KEY is always first", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "datadog",
+            issueTracker: "linear",
+            notification: "slack",
+            githubAction: false,
+            cronExpression: null,
+        });
+        expect(creds[0].key).toBe("ANTHROPIC_API_KEY");
+    });
+    it("ANTHROPIC_API_KEY has correct url", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: null,
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        const anthropic = creds.find((c) => c.key === "ANTHROPIC_API_KEY");
+        expect(anthropic?.url).toBe("https://console.anthropic.com/settings/api-keys");
+    });
+    it("handles unknown provider gracefully (custom observability)", () => {
+        const creds = collectCredentials({
+            sourceControl: "github",
+            observability: "splunk",
+            issueTracker: "github-issues",
+            notification: "console",
+            githubAction: false,
+            cronExpression: null,
+        });
+        // Should still have ANTHROPIC_API_KEY + GITHUB_TOKEN, no crash
+        const keys = creds.map((c) => c.key);
+        expect(keys).toContain("ANTHROPIC_API_KEY");
+        expect(keys).toContain("GITHUB_TOKEN");
+    });
+    it("every provider in PROVIDER_CREDENTIALS has valid credential entries", () => {
+        for (const [provider, creds] of Object.entries(PROVIDER_CREDENTIALS)) {
+            expect(Array.isArray(creds), `${provider} should have an array`).toBe(true);
+            for (const cred of creds) {
+                expect(typeof cred.key, `${provider}.${cred.key} should be a string`).toBe("string");
+                expect(cred.key.length, `${provider} has an empty key`).toBeGreaterThan(0);
+                expect(cred.key, `${provider}.${cred.key} should be UPPER_SNAKE_CASE`).toMatch(/^[A-Z][A-Z0-9_]+$/);
+            }
+        }
+    });
+    it("credential URLs are valid https URLs when present", () => {
+        for (const [provider, creds] of Object.entries(PROVIDER_CREDENTIALS)) {
+            for (const cred of creds) {
+                if (cred.url) {
+                    expect(cred.url, `${provider}.${cred.key} URL should start with https://`).toMatch(/^https:\/\//);
+                }
+            }
+        }
+    });
+});

package/dist/cli/main.js

@@ -19,7 +19,8 @@ import { buildWorkflow, refineWorkflow } from "../workflow-builder.js";
 import { toMermaid, toMermaidBlock } from "../mermaid.js";
 import { DagRenderer } from "./renderer.js";
 import * as readline from "node:readline";
-import { loadDotenv, loadConfigFile, STARTER_CONFIG } from "./config-file.js";
+import { loadDotenv, loadConfigFile } from "./config-file.js";
+import { runInit } from "./init.js";
 import { registerTriageCommand, registerImplementCommand, parseCliInputs, validateInputs, validateWarnings, } from "./config.js";
 import { c, formatBanner, getStepDetails, formatStepLine, formatDagResultHuman, formatResultJson, formatValidationErrors, formatCrashError, formatCheckResults, } from "./output.js";
 import { checkProviderConnectivity } from "./check.js";
@@ -55,16 +56,9 @@ const program = new Command()
 // ── sweny init ────────────────────────────────────────────────────────
 program
     .command("init")
-    .description("Create a starter .sweny.yml config file")
-    .action(() => {
-    const target = path.join(process.cwd(), ".sweny.yml");
-    if (fs.existsSync(target)) {
-        console.error(chalk.yellow("  .sweny.yml already exists — skipping."));
-        process.exit(1);
-    }
-    fs.writeFileSync(target, STARTER_CONFIG, "utf-8");
-    console.log(chalk.green("  Created .sweny.yml"));
-    console.log(chalk.dim("  Add your secrets to .env and run: sweny triage --dry-run"));
+    .description("Interactive setup wizard — creates .sweny.yml, .env template, and optional GitHub Action")
+    .action(async () => {
+    await runInit();
 });
 // ── sweny check ───────────────────────────────────────────────────────
 program

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.30",
+  "version": "0.1.31",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"
@@ -49,6 +49,7 @@
   },
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "^0.2.84",
+    "@clack/prompts": "^1.2.0",
     "chalk": "^5",
     "commander": "^13",
     "yaml": "^2",