@justanarthur/just-github-actions-n-workflows-cli 0.0.0-beta.11 → 0.0.0-beta.13

package/dist/commands/init.js

@@ -0,0 +1,209 @@
+import { Args, Command, Flags, ux } from "@oclif/core";
+import { checkbox, select } from "@inquirer/prompts";
+import { existsSync, mkdirSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { REPO, enrichWorkflows, fetchTags, fetchWorkflowContent, fetchWorkflowList, } from "../github.js";
+import { injectRefComment, mergeLockfile, readLockfile, writeLockfile, } from "../lockfile.js";
+export default class Init extends Command {
+    static description = "Scaffold workflow files into .github/workflows/ of the current repo";
+    static examples = [
+        "<%= config.bin %> init",
+        "<%= config.bin %> init bump-version",
+        "<%= config.bin %> init --ref v1.0.0",
+        "<%= config.bin %> init --list",
+        "<%= config.bin %> init --yes --force",
+    ];
+    static args = {
+        workflows: Args.string({
+            description: "Specific workflow names to install (space-separated)",
+            required: false,
+        }),
+    };
+    static strict = false;
+    static flags = {
+        list: Flags.boolean({
+            char: "l",
+            description: "Show available workflows",
+            default: false,
+        }),
+        force: Flags.boolean({
+            char: "f",
+            description: "Overwrite existing workflow files",
+            default: false,
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip interactive prompts, install all workflows",
+            default: false,
+        }),
+        ref: Flags.string({
+            description: "Git ref to fetch from (branch, tag, or sha)",
+            default: "main",
+        }),
+    };
+    async run() {
+        const { argv, flags } = await this.parse(Init);
+        const positional = argv;
+        // --- list mode ---
+        if (flags.list) {
+            await this.listWorkflows(flags.ref);
+            return;
+        }
+        // --- interactive / install mode ---
+        this.log();
+        this.log(ux.colorize("bold", "  just-github-actions-n-workflows"));
+        this.log(ux.colorize("dim", "  release automation toolkit\n"));
+        const ref = await this.resolveRef(flags, positional);
+        const selected = await this.selectWorkflows(ref, flags, positional);
+        if (selected.length === 0) {
+            this.log(ux.colorize("yellow", "\n  no workflows selected — nothing to do.\n"));
+            return;
+        }
+        const { created, skipped } = await this.installWorkflows(selected, ref, flags);
+        this.log(`\n  done — ${ux.colorize("green", `${created} created`)}, ${skipped} skipped\n`);
+        this.printSecretsReminder(selected);
+        this.printNextSteps(created, selected);
+    }
+    // ── step 1: resolve ref ────────────────────────────────
+    async resolveRef(flags, positional) {
+        if (flags.ref !== "main" || positional.length > 0 || flags.yes) {
+            return flags.ref;
+        }
+        this.log(ux.colorize("bold", "  step 1 — select version\n"));
+        const tags = await fetchTags();
+        if (tags.length === 0)
+            return "main";
+        const choices = [
+            { name: `main ${ux.colorize("dim", "(latest)")}`, value: "main" },
+            ...tags.slice(0, 9).map((tag) => ({ name: tag, value: tag })),
+        ];
+        const ref = await select({
+            message: "Pick a version",
+            choices,
+            default: "main",
+        });
+        this.log(ux.colorize("green", `\n  → using ${ref}\n`));
+        return ref;
+    }
+    // ── step 2: select workflows ───────────────────────────
+    async selectWorkflows(ref, flags, positional) {
+        let available = await fetchWorkflowList(ref);
+        available = await enrichWorkflows(available, ref);
+        if (positional.length > 0) {
+            return positional.map((name) => {
+                const key = name.replace(/\.yml$/, "");
+                const wf = available.find((w) => w.name === key);
+                if (!wf) {
+                    this.error(`Unknown workflow "${name}". Available: ${available.map((w) => w.name).join(", ")}`);
+                }
+                return wf;
+            });
+        }
+        if (flags.yes)
+            return available;
+        this.log(ux.colorize("bold", "  step 2 — select workflows\n"));
+        const selected = await checkbox({
+            message: "Select workflows to install",
+            choices: available.map((wf) => {
+                const secretNames = wf.secrets?.map((s) => s.split(/\s+[—–]\s*/)[0]).join(", ");
+                const hint = [
+                    wf.description,
+                    secretNames ? `requires: ${secretNames}` : null,
+                ].filter(Boolean).join(" · ");
+                return {
+                    name: `${wf.name.padEnd(26)} ${ux.colorize("dim", hint || wf.file)}`,
+                    value: wf.name,
+                    checked: true,
+                };
+            }),
+        });
+        return available.filter((w) => selected.includes(w.name));
+    }
+    // ── step 3: install ────────────────────────────────────
+    async installWorkflows(selected, ref, flags) {
+        const targetDir = join(process.cwd(), ".github", "workflows");
+        mkdirSync(targetDir, { recursive: true });
+        if (!flags.yes) {
+            this.log(ux.colorize("bold", "  step 3 — install\n"));
+        }
+        this.log(ux.colorize("dim", `  fetching from ${REPO} @ ${ref}\n`));
+        let created = 0;
+        let skipped = 0;
+        const installed = [];
+        for (const workflow of selected) {
+            const targetPath = join(targetDir, workflow.file);
+            if (!flags.force && existsSync(targetPath)) {
+                this.log(`  ${ux.colorize("yellow", "skip")}    ${workflow.file} ${ux.colorize("dim", "(already exists, use --force)")}`);
+                skipped++;
+                continue;
+            }
+            try {
+                let content = await fetchWorkflowContent(workflow.file, ref);
+                content = injectRefComment(content, ref);
+                writeFileSync(targetPath, content, "utf-8");
+                this.log(`  ${ux.colorize("green", "create")}  .github/workflows/${workflow.file}`);
+                installed.push({ name: workflow.name, file: workflow.file });
+                created++;
+            }
+            catch (error) {
+                this.log(`  ${ux.colorize("red", "error")}   ${workflow.file}: ${error.message}`);
+            }
+        }
+        // --- write lock file ---
+        if (installed.length > 0) {
+            const existing = readLockfile();
+            const lock = mergeLockfile(existing, ref, installed);
+            writeLockfile(lock);
+            this.log(ux.colorize("dim", `\n  lock file written → .github/workflows/.toolkit-lock.json`));
+        }
+        return { created, skipped };
+    }
+    // ── step 4: secrets reminder ───────────────────────────
+    printSecretsReminder(selected) {
+        const allSecrets = new Map();
+        for (const wf of selected) {
+            for (const s of wf.secrets || []) {
+                const [name, ...descParts] = s.split(/\s+[—–]\s*/);
+                if (name && !allSecrets.has(name.trim())) {
+                    allSecrets.set(name.trim(), descParts.join(" — ").trim());
+                }
+            }
+        }
+        if (allSecrets.size === 0)
+            return;
+        this.log(ux.colorize("bold", "  required secrets:\n"));
+        for (const [name, desc] of allSecrets) {
+            this.log(`  • ${ux.colorize("cyan", name.padEnd(18))} ${ux.colorize("dim", desc)}`);
+        }
+        this.log(ux.colorize("dim", `\n  set these in your repo → Settings → Secrets → Actions\n`));
+    }
+    // ── next steps ─────────────────────────────────────────
+    printNextSteps(created, selected) {
+        if (created === 0)
+            return;
+        const hasSecrets = selected.some((w) => w.secrets && w.secrets.length > 0);
+        this.log(ux.colorize("bold", "  next steps:\n"));
+        this.log(`  1. ${hasSecrets ? "set the secrets listed above" : "set the GH_TOKEN secret in your repo settings"}`);
+        this.log(`  2. adjust push.branches / push.tags triggers for your repo`);
+        this.log(`  3. commit and push:`);
+        this.log(ux.colorize("dim", `     git add .github/ && git commit -m "ci: add workflows" && git push`));
+        this.log();
+    }
+    // ── list mode ──────────────────────────────────────────
+    async listWorkflows(ref) {
+        const workflows = await enrichWorkflows(await fetchWorkflowList(ref), ref);
+        this.log(`\n${ux.colorize("bold", "available workflows")} ${ux.colorize("dim", `(${REPO} @ ${ref})`)}\n`);
+        for (const w of workflows) {
+            this.log(`  ${ux.colorize("cyan", w.name.padEnd(28))} → .github/workflows/${w.file}`);
+            if (w.description) {
+                this.log(`  ${"".padEnd(28)}   ${ux.colorize("dim", w.description)}`);
+            }
+            if (w.secrets?.length) {
+                const names = w.secrets.map((s) => s.split(/\s+[—–]\s*/)[0]).join(", ");
+                this.log(`  ${"".padEnd(28)}   ${ux.colorize("dim", `secrets: ${names}`)}`);
+            }
+            this.log();
+        }
+    }
+}
+//# sourceMappingURL=init.js.map

package/dist/commands/status.js

@@ -0,0 +1,53 @@
+// cli/src/commands/status.ts
+// ---
+// shows the current state of installed workflows:
+// version, install date, and whether each is outdated.
+// ---
+import { Command, Flags, ux } from "@oclif/core";
+import { fetchLatestTag } from "../github.js";
+import { readLockfile } from "../lockfile.js";
+export default class Status extends Command {
+    static description = "Show the status of installed workflows";
+    static examples = [
+        "<%= config.bin %> status",
+        "<%= config.bin %> status --ref v2.0.0",
+    ];
+    static flags = {
+        ref: Flags.string({
+            description: "Compare against this ref instead of the latest tag",
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Status);
+        const lock = readLockfile();
+        if (!lock || Object.keys(lock.workflows).length === 0) {
+            this.log(ux.colorize("yellow", "\n  no workflows installed — run `init` first.\n"));
+            return;
+        }
+        const targetRef = flags.ref ?? await fetchLatestTag();
+        const entries = Object.values(lock.workflows);
+        this.log();
+        this.log(ux.colorize("bold", "  installed workflows"));
+        this.log(ux.colorize("dim", `  latest: ${targetRef}\n`));
+        let outdatedCount = 0;
+        for (const entry of entries) {
+            const current = entry.ref === targetRef;
+            const icon = current ? ux.colorize("green", "✓") : ux.colorize("yellow", "⬆");
+            const refLabel = current
+                ? ux.colorize("green", entry.ref)
+                : `${ux.colorize("yellow", entry.ref)} → ${ux.colorize("green", targetRef)}`;
+            const date = ux.colorize("dim", new Date(entry.installedAt).toLocaleDateString());
+            this.log(`  ${icon} ${ux.colorize("cyan", entry.name.padEnd(28))} ${refLabel.padEnd(50)} ${date}`);
+            if (!current)
+                outdatedCount++;
+        }
+        this.log();
+        if (outdatedCount > 0) {
+            this.log(ux.colorize("yellow", `  ${outdatedCount} workflow(s) can be updated — run \`update\` to upgrade.\n`));
+        }
+        else {
+            this.log(ux.colorize("green", `  all ${entries.length} workflow(s) are up to date.\n`));
+        }
+    }
+}
+//# sourceMappingURL=status.js.map

package/dist/commands/update.js

@@ -0,0 +1,108 @@
+// cli/src/commands/update.ts
+// ---
+// updates previously installed workflows to a newer version.
+// reads .toolkit-lock.json to find installed workflows, then
+// re-fetches them from the specified (or latest) git ref.
+// ---
+import { Command, Flags, ux } from "@oclif/core";
+import { confirm } from "@inquirer/prompts";
+import { writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { REPO, fetchLatestTag, fetchWorkflowContent, } from "../github.js";
+import { injectRefComment, mergeLockfile, readLockfile, writeLockfile, } from "../lockfile.js";
+export default class Update extends Command {
+    static description = "Update installed workflows to a newer version";
+    static examples = [
+        "<%= config.bin %> update",
+        "<%= config.bin %> update --ref v2.0.0",
+        "<%= config.bin %> update --yes",
+    ];
+    static flags = {
+        ref: Flags.string({
+            description: "Target git ref to update to (branch, tag, or sha)",
+        }),
+        yes: Flags.boolean({
+            char: "y",
+            description: "Skip confirmation prompt",
+            default: false,
+        }),
+    };
+    async run() {
+        const { flags } = await this.parse(Update);
+        // --- read lock file ---
+        const lock = readLockfile();
+        if (!lock || Object.keys(lock.workflows).length === 0) {
+            this.error("No .toolkit-lock.json found. Run `init` first to install workflows.", { exit: 1 });
+        }
+        // --- resolve target ref ---
+        const targetRef = flags.ref ?? await fetchLatestTag();
+        const entries = Object.values(lock.workflows);
+        this.log();
+        this.log(ux.colorize("bold", "  workflow update check"));
+        this.log(ux.colorize("dim", `  target: ${targetRef}\n`));
+        // --- compare versions ---
+        const outdated = [];
+        const upToDate = [];
+        for (const entry of entries) {
+            if (entry.ref === targetRef) {
+                upToDate.push(entry);
+            }
+            else {
+                outdated.push(entry);
+            }
+        }
+        // --- print status table ---
+        for (const entry of entries) {
+            const current = entry.ref === targetRef;
+            const icon = current ? ux.colorize("green", "✓") : ux.colorize("yellow", "⬆");
+            const refLabel = current
+                ? ux.colorize("green", entry.ref)
+                : `${ux.colorize("yellow", entry.ref)} → ${ux.colorize("green", targetRef)}`;
+            this.log(`  ${icon} ${ux.colorize("cyan", entry.name.padEnd(28))} ${refLabel}`);
+        }
+        this.log();
+        if (outdated.length === 0) {
+            this.log(ux.colorize("green", `  all ${entries.length} workflow(s) are up to date at ${targetRef}\n`));
+            return;
+        }
+        // --- confirm ---
+        if (!flags.yes) {
+            const proceed = await confirm({
+                message: `Update ${outdated.length} workflow(s) to ${targetRef}?`,
+                default: true,
+            });
+            if (!proceed) {
+                this.log(ux.colorize("yellow", "\n  cancelled.\n"));
+                return;
+            }
+            this.log();
+        }
+        // --- update files ---
+        const targetDir = join(process.cwd(), ".github", "workflows");
+        let updated = 0;
+        let errors = 0;
+        const updatedEntries = [];
+        this.log(ux.colorize("dim", `  fetching from ${REPO} @ ${targetRef}\n`));
+        for (const entry of outdated) {
+            try {
+                let content = await fetchWorkflowContent(entry.file, targetRef);
+                content = injectRefComment(content, targetRef);
+                writeFileSync(join(targetDir, entry.file), content, "utf-8");
+                this.log(`  ${ux.colorize("green", "update")}  ${entry.file} ${ux.colorize("dim", `(${entry.ref} → ${targetRef})`)}`);
+                updatedEntries.push({ name: entry.name, file: entry.file });
+                updated++;
+            }
+            catch (error) {
+                this.log(`  ${ux.colorize("red", "error")}   ${entry.file}: ${error.message}`);
+                errors++;
+            }
+        }
+        // --- update lock file ---
+        if (updatedEntries.length > 0) {
+            const updatedLock = mergeLockfile(lock, targetRef, updatedEntries);
+            writeLockfile(updatedLock);
+        }
+        this.log(`\n  done — ${ux.colorize("green", `${updated} updated`)}, ${errors} errors, ${upToDate.length} already current\n`);
+    }
+}
+//# sourceMappingURL=update.js.map

package/dist/github.js

@@ -0,0 +1,96 @@
+import { createRequire } from "node:module";
+const require = createRequire(import.meta.url);
+const pkg = require("../package.json");
+const REPO = pkg.repository.url
+    .replace(/^https?:\/\/github\.com\//, "")
+    .replace(/\.git$/, "");
+const API_BASE = `https://api.github.com/repos/${REPO}`;
+const RAW_BASE = `https://raw.githubusercontent.com/${REPO}`;
+export { REPO };
+// --- parse workflow header ---
+// extracts description and required secrets from the yaml header comment block.
+export function parseWorkflowHeader(content) {
+    const lines = content.split("\n");
+    let description = "";
+    const secrets = [];
+    let inHeader = false;
+    for (const line of lines) {
+        if (line.startsWith("# ---")) {
+            if (inHeader)
+                break;
+            inHeader = true;
+            continue;
+        }
+        if (!inHeader)
+            continue;
+        if (!line.startsWith("#"))
+            break;
+        const text = line.replace(/^#\s?/, "").trim();
+        if (/^required secrets:/i.test(text))
+            continue;
+        if (/^\w+\s+[—–]/.test(text)) {
+            secrets.push(text);
+            continue;
+        }
+        if (!description && text && !/^copy this|^can also|^actions used|^paste this|^this one/i.test(text)) {
+            description = text;
+        }
+    }
+    return { description, secrets };
+}
+// --- api ---
+export async function fetchTags() {
+    const url = `${API_BASE}/tags?per_page=20`;
+    const res = await fetch(url, {
+        headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!res.ok)
+        return [];
+    const tags = await res.json();
+    return tags.map((t) => t.name);
+}
+// --- fetchLatestTag ---
+// returns the most recent tag, or "main" if no tags exist.
+export async function fetchLatestTag() {
+    const tags = await fetchTags();
+    return tags.length > 0 ? tags[0] : "main";
+}
+export async function fetchWorkflowList(gitRef) {
+    const url = `${API_BASE}/contents/workflows?ref=${gitRef}`;
+    const res = await fetch(url, {
+        headers: { Accept: "application/vnd.github.v3+json" }
+    });
+    if (!res.ok) {
+        throw new Error(`failed to list workflows from ${REPO} @ ${gitRef} (${res.status})`);
+    }
+    const entries = await res.json();
+    return entries
+        .filter((e) => e.type === "file" && e.name.endsWith(".yml"))
+        .map((e) => ({
+        name: e.name.replace(/\.yml$/, ""),
+        file: e.name
+    }));
+}
+export async function fetchWorkflowContent(file, gitRef) {
+    const url = `${RAW_BASE}/${gitRef}/workflows/${file}`;
+    const res = await fetch(url);
+    if (!res.ok) {
+        throw new Error(`failed to fetch workflows/${file} from ${REPO} @ ${gitRef} (${res.status})`);
+    }
+    return await res.text();
+}
+export async function enrichWorkflows(workflows, gitRef) {
+    const enriched = [];
+    for (const wf of workflows) {
+        try {
+            const content = await fetchWorkflowContent(wf.file, gitRef);
+            const { description, secrets } = parseWorkflowHeader(content);
+            enriched.push({ ...wf, description, secrets });
+        }
+        catch {
+            enriched.push(wf);
+        }
+    }
+    return enriched;
+}
+//# sourceMappingURL=github.js.map

package/dist/index.js

@@ -0,0 +1,6 @@
+// cli/src/index.ts
+// ---
+// oclif entry point — re-exported for use by bin/run.js
+// ---
+export { execute } from "@oclif/core";
+//# sourceMappingURL=index.js.map

package/{src/init.ts → dist/init.js}

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
-
+"use strict";
 // This file has been replaced by:
 //   src/index.ts          — oclif entry point
 //   src/commands/init.ts   — init command
 //   src/github.ts          — github api helpers
 //
 // You can safely delete this file.
+//# sourceMappingURL=init.js.map

package/dist/lockfile.js

@@ -0,0 +1,72 @@
+// cli/src/lockfile.ts
+// ---
+// reads and writes .github/workflows/.toolkit-lock.json
+// tracks which version (git ref) each workflow was installed from.
+// ---
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+// --- constants ---
+const LOCKFILE_NAME = ".toolkit-lock.json";
+export function lockfilePath() {
+    return join(process.cwd(), ".github", "workflows", LOCKFILE_NAME);
+}
+// --- read ---
+export function readLockfile() {
+    const path = lockfilePath();
+    if (!existsSync(path))
+        return null;
+    try {
+        const raw = readFileSync(path, "utf-8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
+// --- write ---
+export function writeLockfile(lock) {
+    const path = lockfilePath();
+    writeFileSync(path, JSON.stringify(lock, null, 2) + "\n", "utf-8");
+}
+// --- merge ---
+// merges new entries into an existing lockfile (or creates a new one).
+export function mergeLockfile(existing, ref, entries) {
+    const now = new Date().toISOString();
+    const lock = existing ?? {
+        ref,
+        installedAt: now,
+        workflows: {},
+    };
+    lock.ref = ref;
+    lock.installedAt = now;
+    for (const entry of entries) {
+        lock.workflows[entry.file] = {
+            name: entry.name,
+            file: entry.file,
+            ref,
+            installedAt: now,
+        };
+    }
+    return lock;
+}
+// --- version comment ---
+// prepends a `# toolkit-ref: <ref>` comment to workflow content.
+export function injectRefComment(content, ref) {
+    const marker = "# toolkit-ref:";
+    const comment = `${marker} ${ref}`;
+    // replace existing marker if present
+    if (content.includes(marker)) {
+        return content.replace(/^# toolkit-ref:.*$/m, comment);
+    }
+    // prepend before first non-comment, non-empty line
+    const lines = content.split("\n");
+    const insertIdx = lines.findIndex((l) => l.trim() !== "" && !l.startsWith("#"));
+    if (insertIdx >= 0) {
+        lines.splice(insertIdx, 0, comment);
+    }
+    else {
+        lines.push(comment);
+    }
+    return lines.join("\n");
+}
+//# sourceMappingURL=lockfile.js.map

package/package.json

@@ -1,14 +1,17 @@
 {
   "name": "@justanarthur/just-github-actions-n-workflows-cli",
-  "version": "0.0.0-beta.11",
+  "version": "0.0.0-beta.13",
   "description": "Release automation toolkit — version bumping, npm publishing, docker publishing, VPS deployment via GitHub Actions composite actions",
   "type": "module",
   "bin": {
-    "just-github-actions-n-workflows": "./src/index.ts"
+    "just-github-actions-n-workflows": "./bin/run.js"
+  },
+  "scripts": {
+    "build": "tsc"
   },
-  "scripts": {},
   "files": [
-    "src/**/*.ts",
+    "bin/**/*.js",
+    "dist/**/*.js",
     "package.json",
     "README.md"
   ],
@@ -23,8 +26,11 @@
     "@oclif/core": "^4",
     "@inquirer/prompts": "^7"
   },
+  "devDependencies": {
+    "typescript": "^5"
+  },
   "oclif": {
-    "commands": "./src/commands",
+    "commands": "./dist/commands",
     "default": "init"
   },
   "properties": {

package/src/commands/init.ts

@@ -1,265 +0,0 @@
-import { Args, Command, Flags, ux } from "@oclif/core"
-import { checkbox, select } from "@inquirer/prompts"
-import { existsSync, mkdirSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-
-import {
-  REPO,
-  enrichWorkflows,
-  fetchTags,
-  fetchWorkflowContent,
-  fetchWorkflowList,
-  type WorkflowEntry,
-} from "../github.js"
-
-export default class Init extends Command {
-  static override description = "Scaffold workflow files into .github/workflows/ of the current repo"
-
-  static override examples = [
-    "<%= config.bin %> init",
-    "<%= config.bin %> init bump-version",
-    "<%= config.bin %> init --ref v1.0.0",
-    "<%= config.bin %> init --list",
-    "<%= config.bin %> init --yes --force",
-  ]
-
-  static override args = {
-    workflows: Args.string({
-      description: "Specific workflow names to install (space-separated)",
-      required: false,
-    }),
-  }
-
-  static override strict = false
-
-  static override flags = {
-    list: Flags.boolean({
-      char: "l",
-      description: "Show available workflows",
-      default: false,
-    }),
-    force: Flags.boolean({
-      char: "f",
-      description: "Overwrite existing workflow files",
-      default: false,
-    }),
-    yes: Flags.boolean({
-      char: "y",
-      description: "Skip interactive prompts, install all workflows",
-      default: false,
-    }),
-    ref: Flags.string({
-      description: "Git ref to fetch from (branch, tag, or sha)",
-      default: "main",
-    }),
-  }
-
-  async run(): Promise<void> {
-    const { argv, flags } = await this.parse(Init)
-    const positional = argv as string[]
-
-    // --- list mode ---
-
-    if (flags.list) {
-      await this.listWorkflows(flags.ref)
-      return
-    }
-
-    // --- interactive / install mode ---
-
-    this.log()
-    this.log(ux.colorize("bold", "  just-github-actions-n-workflows"))
-    this.log(ux.colorize("dim", "  release automation toolkit\n"))
-
-    const ref = await this.resolveRef(flags, positional)
-    const selected = await this.selectWorkflows(ref, flags, positional)
-
-    if (selected.length === 0) {
-      this.log(ux.colorize("yellow", "\n  no workflows selected — nothing to do.\n"))
-      return
-    }
-
-    const { created, skipped } = await this.installWorkflows(selected, ref, flags)
-
-    this.log(`\n  done — ${ux.colorize("green", `${created} created`)}, ${skipped} skipped\n`)
-
-    this.printSecretsReminder(selected)
-    this.printNextSteps(created, selected)
-  }
-
-  // ── step 1: resolve ref ────────────────────────────────
-
-  private async resolveRef(
-    flags: { ref: string; yes: boolean },
-    positional: string[]
-  ): Promise<string> {
-    if (flags.ref !== "main" || positional.length > 0 || flags.yes) {
-      return flags.ref
-    }
-
-    this.log(ux.colorize("bold", "  step 1 — select version\n"))
-
-    const tags = await fetchTags()
-
-    if (tags.length === 0) return "main"
-
-    const choices = [
-      { name: `main ${ux.colorize("dim", "(latest)")}`, value: "main" },
-      ...tags.slice(0, 9).map((tag) => ({ name: tag, value: tag })),
-    ]
-
-    const ref = await select({
-      message: "Pick a version",
-      choices,
-      default: "main",
-    })
-
-    this.log(ux.colorize("green", `\n  → using ${ref}\n`))
-    return ref
-  }
-
-  // ── step 2: select workflows ───────────────────────────
-
-  private async selectWorkflows(
-    ref: string,
-    flags: { yes: boolean },
-    positional: string[]
-  ): Promise<WorkflowEntry[]> {
-    let available = await fetchWorkflowList(ref)
-    available = await enrichWorkflows(available, ref)
-
-    if (positional.length > 0) {
-      return positional.map((name) => {
-        const key = name.replace(/\.yml$/, "")
-        const wf = available.find((w) => w.name === key)
-        if (!wf) {
-          this.error(`Unknown workflow "${name}". Available: ${available.map((w) => w.name).join(", ")}`)
-        }
-        return wf!
-      })
-    }
-
-    if (flags.yes) return available
-
-    this.log(ux.colorize("bold", "  step 2 — select workflows\n"))
-
-    const selected = await checkbox({
-      message: "Select workflows to install",
-      choices: available.map((wf) => {
-        const secretNames = wf.secrets?.map((s) => s.split(/\s+[—–]\s*/)[0]).join(", ")
-        const hint = [
-          wf.description,
-          secretNames ? `requires: ${secretNames}` : null,
-        ].filter(Boolean).join(" · ")
-
-        return {
-          name: `${wf.name.padEnd(26)} ${ux.colorize("dim", hint || wf.file)}`,
-          value: wf.name,
-          checked: true,
-        }
-      }),
-    })
-
-    return available.filter((w) => selected.includes(w.name))
-  }
-
-  // ── step 3: install ────────────────────────────────────
-
-  private async installWorkflows(
-    selected: WorkflowEntry[],
-    ref: string,
-    flags: { force: boolean; yes: boolean }
-  ): Promise<{ created: number; skipped: number }> {
-    const targetDir = join(process.cwd(), ".github", "workflows")
-    mkdirSync(targetDir, { recursive: true })
-
-    if (!flags.yes) {
-      this.log(ux.colorize("bold", "  step 3 — install\n"))
-    }
-
-    this.log(ux.colorize("dim", `  fetching from ${REPO} @ ${ref}\n`))
-
-    let created = 0
-    let skipped = 0
-
-    for (const workflow of selected) {
-      const targetPath = join(targetDir, workflow.file)
-
-      if (!flags.force && existsSync(targetPath)) {
-        this.log(`  ${ux.colorize("yellow", "skip")}    ${workflow.file} ${ux.colorize("dim", "(already exists, use --force)")}`)
-        skipped++
-        continue
-      }
-
-      try {
-        const content = await fetchWorkflowContent(workflow.file, ref)
-        writeFileSync(targetPath, content, "utf-8")
-        this.log(`  ${ux.colorize("green", "create")}  .github/workflows/${workflow.file}`)
-        created++
-      } catch (error: any) {
-        this.log(`  ${ux.colorize("red", "error")}   ${workflow.file}: ${error.message}`)
-      }
-    }
-
-    return { created, skipped }
-  }
-
-  // ── step 4: secrets reminder ───────────────────────────
-
-  private printSecretsReminder(selected: WorkflowEntry[]): void {
-    const allSecrets = new Map<string, string>()
-    for (const wf of selected) {
-      for (const s of wf.secrets || []) {
-        const [name, ...descParts] = s.split(/\s+[—–]\s*/)
-        if (name && !allSecrets.has(name.trim())) {
-          allSecrets.set(name.trim(), descParts.join(" — ").trim())
-        }
-      }
-    }
-
-    if (allSecrets.size === 0) return
-
-    this.log(ux.colorize("bold", "  required secrets:\n"))
-    for (const [name, desc] of allSecrets) {
-      this.log(`  • ${ux.colorize("cyan", name.padEnd(18))} ${ux.colorize("dim", desc)}`)
-    }
-    this.log(ux.colorize("dim", `\n  set these in your repo → Settings → Secrets → Actions\n`))
-  }
-
-  // ── next steps ─────────────────────────────────────────
-
-  private printNextSteps(created: number, selected: WorkflowEntry[]): void {
-    if (created === 0) return
-
-    const hasSecrets = selected.some((w) => w.secrets && w.secrets.length > 0)
-
-    this.log(ux.colorize("bold", "  next steps:\n"))
-    this.log(`  1. ${hasSecrets ? "set the secrets listed above" : "set the GH_TOKEN secret in your repo settings"}`)
-    this.log(`  2. adjust push.branches / push.tags triggers for your repo`)
-    this.log(`  3. commit and push:`)
-    this.log(ux.colorize("dim", `     git add .github/ && git commit -m "ci: add workflows" && git push`))
-    this.log()
-  }
-
-  // ── list mode ──────────────────────────────────────────
-
-  private async listWorkflows(ref: string): Promise<void> {
-    const workflows = await enrichWorkflows(await fetchWorkflowList(ref), ref)
-
-    this.log(`\n${ux.colorize("bold", "available workflows")} ${ux.colorize("dim", `(${REPO} @ ${ref})`)}\n`)
-
-    for (const w of workflows) {
-      this.log(`  ${ux.colorize("cyan", w.name.padEnd(28))} → .github/workflows/${w.file}`)
-      if (w.description) {
-        this.log(`  ${"".padEnd(28)}   ${ux.colorize("dim", w.description)}`)
-      }
-      if (w.secrets?.length) {
-        const names = w.secrets.map((s) => s.split(/\s+[—–]\s*/)[0]).join(", ")
-        this.log(`  ${"".padEnd(28)}   ${ux.colorize("dim", `secrets: ${names}`)}`)
-      }
-      this.log()
-    }
-  }
-}
-
-

package/src/github.ts

@@ -1,113 +0,0 @@
-import pkg from "../package.json"
-
-const REPO = pkg.repository.url
-  .replace(/^https?:\/\/github\.com\//, "")
-  .replace(/\.git$/, "")
-
-const API_BASE = `https://api.github.com/repos/${REPO}`
-const RAW_BASE = `https://raw.githubusercontent.com/${REPO}`
-
-export { REPO }
-
-// --- types ---
-
-export type WorkflowEntry = {
-  name: string
-  file: string
-  description?: string
-  secrets?: string[]
-}
-
-// --- parse workflow header ---
-// extracts description and required secrets from the yaml header comment block.
-
-export function parseWorkflowHeader(content: string): { description: string; secrets: string[] } {
-  const lines = content.split("\n")
-  let description = ""
-  const secrets: string[] = []
-  let inHeader = false
-
-  for (const line of lines) {
-    if (line.startsWith("# ---")) {
-      if (inHeader) break
-      inHeader = true
-      continue
-    }
-    if (!inHeader) continue
-    if (!line.startsWith("#")) break
-
-    const text = line.replace(/^#\s?/, "").trim()
-
-    if (/^required secrets:/i.test(text)) continue
-    if (/^\w+\s+[—–]/.test(text)) {
-      secrets.push(text)
-      continue
-    }
-
-    if (!description && text && !/^copy this|^can also|^actions used|^paste this|^this one/i.test(text)) {
-      description = text
-    }
-  }
-
-  return { description, secrets }
-}
-
-// --- api ---
-
-export async function fetchTags(): Promise<string[]> {
-  const url = `${API_BASE}/tags?per_page=20`
-  const res = await fetch(url, {
-    headers: { Accept: "application/vnd.github.v3+json" }
-  })
-  if (!res.ok) return []
-  const tags: any[] = await res.json()
-  return tags.map((t) => t.name)
-}
-
-export async function fetchWorkflowList(gitRef: string): Promise<WorkflowEntry[]> {
-  const url = `${API_BASE}/contents/workflows?ref=${gitRef}`
-  const res = await fetch(url, {
-    headers: { Accept: "application/vnd.github.v3+json" }
-  })
-
-  if (!res.ok) {
-    throw new Error(`failed to list workflows from ${REPO} @ ${gitRef} (${res.status})`)
-  }
-
-  const entries: any[] = await res.json()
-
-  return entries
-    .filter((e) => e.type === "file" && e.name.endsWith(".yml"))
-    .map((e) => ({
-      name: e.name.replace(/\.yml$/, ""),
-      file: e.name
-    }))
-}
-
-export async function fetchWorkflowContent(file: string, gitRef: string): Promise<string> {
-  const url = `${RAW_BASE}/${gitRef}/workflows/${file}`
-  const res = await fetch(url)
-
-  if (!res.ok) {
-    throw new Error(`failed to fetch workflows/${file} from ${REPO} @ ${gitRef} (${res.status})`)
-  }
-
-  return await res.text()
-}
-
-export async function enrichWorkflows(workflows: WorkflowEntry[], gitRef: string): Promise<WorkflowEntry[]> {
-  const enriched: WorkflowEntry[] = []
-
-  for (const wf of workflows) {
-    try {
-      const content = await fetchWorkflowContent(wf.file, gitRef)
-      const { description, secrets } = parseWorkflowHeader(content)
-      enriched.push({ ...wf, description, secrets })
-    } catch {
-      enriched.push(wf)
-    }
-  }
-
-  return enriched
-}
-