brn-toolkit 1.0.0

package/dist/cli/brn.js

@@ -0,0 +1,274 @@
+#!/usr/bin/env node
+/**
+ * BRN-Toolkit CLI - Main entry point
+ * Usage: brn <command> [options]
+ */
+import { $ } from "zx";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { homedir } from "os";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import * as readline from "readline";
+import YAML from "yaml";
+$.verbose = false;
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Handle both source (cli/brn.ts) and compiled (dist/cli/brn.js) locations
+const isCompiled = __dirname.includes(join("dist", "cli"));
+const PROJECT_ROOT = isCompiled ? join(__dirname, "..", "..") : join(__dirname, "..");
+const BRN_DIR = join(homedir(), ".brn");
+const CONFIG_FILE = join(BRN_DIR, "config.yaml");
+// Simple readline interface for prompts
+function prompt(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+async function runSkill(skill, script, args) {
+    // Determine where to look for scripts
+    // Prefer dist/skills/.../*.js for speed, fallback to skills/.../*.ts
+    const distScriptsDir = join(PROJECT_ROOT, "dist", "skills", skill, "scripts");
+    const srcScriptsDir = join(PROJECT_ROOT, "skills", skill, "scripts");
+    const jsPath = join(distScriptsDir, `${script}.js`);
+    const tsPath = join(srcScriptsDir, `${script}.ts`);
+    const shPath = join(srcScriptsDir, `${script}.sh`);
+    // Enable verbose to show output of the child script
+    const previousVerbose = $.verbose;
+    $.verbose = true;
+    try {
+        if (existsSync(jsPath)) {
+            // Run compiled JS with node
+            await $ `node ${jsPath} ${args}`;
+        }
+        else if (existsSync(tsPath)) {
+            // Run TS with tsx
+            await $ `npx tsx ${tsPath} ${args}`;
+        }
+        else if (existsSync(shPath)) {
+            // Run shell
+            await $ `bash ${shPath} ${args}`;
+        }
+        else {
+            // Try without extension in src
+            const exactPath = join(srcScriptsDir, script);
+            if (existsSync(exactPath)) {
+                if (script.endsWith(".sh"))
+                    await $ `bash ${exactPath} ${args}`;
+                else
+                    await $ `npx tsx ${exactPath} ${args}`;
+            }
+            else {
+                console.error(`Skill script not found: ${skill}/${script}`);
+                process.exit(1);
+            }
+        }
+    }
+    finally {
+        $.verbose = previousVerbose;
+    }
+}
+async function setup() {
+    console.log("");
+    console.log("🚀 BRN Setup Wizard");
+    console.log("===================");
+    console.log("");
+    // Create config directory
+    if (!existsSync(BRN_DIR)) {
+        mkdirSync(BRN_DIR, { recursive: true });
+        console.log(`✓ Created ${BRN_DIR}`);
+    }
+    // Check for existing config
+    let config = { version: "1.0", active_workspace: "", workspaces: {} };
+    if (existsSync(CONFIG_FILE)) {
+        config = YAML.parse(readFileSync(CONFIG_FILE, "utf-8"));
+        console.log(`✓ Found existing config with ${Object.keys(config.workspaces).length} workspace(s)`);
+        console.log("");
+    }
+    // Workspace name
+    const defaultName = Object.keys(config.workspaces).length === 0 ? "personal" : "";
+    const name = await prompt(`Workspace name [${defaultName}]: `) || defaultName;
+    if (!name) {
+        console.log("❌ Workspace name is required");
+        process.exit(1);
+    }
+    // Work directory
+    const defaultPath = join(homedir(), "dev", name, "auto");
+    const workDir = await prompt(`Work directory [${defaultPath}]: `) || defaultPath;
+    // GitHub token (optional)
+    console.log("");
+    console.log("📦 GitHub Configuration (optional, press Enter to skip)");
+    const githubToken = await prompt("GitHub token: ");
+    const githubOrg = await prompt("Default GitHub Organization/User: ");
+    // JIRA config (optional)
+    console.log("");
+    console.log("📋 JIRA Configuration (optional, press Enter to skip)");
+    const jiraUrl = await prompt("JIRA URL (e.g., https://company.atlassian.net): ");
+    let jiraEmail = "";
+    let jiraToken = "";
+    if (jiraUrl) {
+        jiraEmail = await prompt("JIRA email: ");
+        jiraToken = await prompt("JIRA API token: ");
+    }
+    // Automation settings
+    console.log("");
+    console.log("⚙️  Automation Settings");
+    console.log("   By default, all automation is OFF for safety.");
+    const enableAuto = await prompt("Enable any automation? (y/N): ");
+    let automation = {
+        github_auto_push: false,
+        github_auto_pr: false,
+        jira_auto_transition: false,
+        jira_auto_comment: false,
+    };
+    if (enableAuto.toLowerCase() === "y") {
+        const autoPush = await prompt("  Auto-push commits? (y/N): ");
+        const autoPr = await prompt("  Auto-create PRs? (y/N): ");
+        const autoTransition = await prompt("  Auto-update JIRA status? (y/N): ");
+        const autoComment = await prompt("  Auto-add JIRA comments? (y/N): ");
+        automation = {
+            github_auto_push: autoPush.toLowerCase() === "y",
+            github_auto_pr: autoPr.toLowerCase() === "y",
+            jira_auto_transition: autoTransition.toLowerCase() === "y",
+            jira_auto_comment: autoComment.toLowerCase() === "y",
+        };
+    }
+    // Build workspace config
+    const workspace = {
+        path: workDir,
+        automation,
+    };
+    if (githubToken)
+        workspace.github_token = githubToken;
+    if (githubOrg)
+        workspace.github_org = githubOrg;
+    if (jiraUrl) {
+        workspace.jira_url = jiraUrl;
+        workspace.jira_email = jiraEmail;
+        workspace.jira_token = jiraToken;
+    }
+    // Save config
+    config.workspaces[name] = workspace;
+    if (!config.active_workspace) {
+        config.active_workspace = name;
+    }
+    writeFileSync(CONFIG_FILE, YAML.stringify(config));
+    // Create work directory
+    if (!existsSync(workDir)) {
+        mkdirSync(workDir, { recursive: true });
+    }
+    console.log("");
+    console.log("✅ Setup complete!");
+    console.log("");
+    console.log(`   Workspace: ${name}`);
+    console.log(`   Work dir:  ${workDir}`);
+    console.log(`   Config:    ${CONFIG_FILE}`);
+    console.log("");
+    console.log("Next steps:");
+    console.log("  • Use 'brn workspace list' to see workspaces");
+    console.log("  • Use 'brn workspace switch <name>' to change workspace");
+    console.log("  • Ask your AI assistant to 'list my JIRA tickets'");
+    console.log("");
+}
+async function workspaceList() {
+    if (!existsSync(CONFIG_FILE)) {
+        console.log("No workspaces configured. Run: brn setup");
+        return;
+    }
+    const config = YAML.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    const active = config.active_workspace;
+    console.log("Workspaces:");
+    console.log("===========");
+    for (const [name, ws] of Object.entries(config.workspaces)) {
+        const workspace = ws;
+        const marker = name === active ? "* " : "  ";
+        const activeLabel = name === active ? " [ACTIVE]" : "";
+        console.log(`${marker}${name} (${workspace.path})${activeLabel}`);
+    }
+}
+async function workspaceSwitch(name) {
+    if (!existsSync(CONFIG_FILE)) {
+        console.log("No workspaces configured. Run: brn setup");
+        return;
+    }
+    const config = YAML.parse(readFileSync(CONFIG_FILE, "utf-8"));
+    if (!config.workspaces[name]) {
+        console.log(`Workspace '${name}' not found.`);
+        console.log("Available:", Object.keys(config.workspaces).join(", "));
+        return;
+    }
+    config.active_workspace = name;
+    writeFileSync(CONFIG_FILE, YAML.stringify(config));
+    console.log(`✓ Switched to workspace '${name}'`);
+}
+function showHelp() {
+    console.log(`
+BRN - AI Developer Workflow Toolkit
+
+Usage:
+  brn <command> [options]
+  brn <skill> <script> [args]
+
+Commands:
+  start <ticket>        Shortcut for workflow start <ticket>
+  setup                 Interactive setup wizard
+  workspace list        List all workspaces
+  workspace switch <n>  Switch to workspace <n>
+  help                  Show this help
+
+Skills:
+  github <script>       Run a GitHub skill script (e.g., list_repos)
+  jira <script>         Run a JIRA skill script (e.g., list_tickets)
+  git-worktree <script> Run a Git Worktree skill script (e.g., clone_repo)
+
+Examples:
+  brn start PROJ-123
+  brn github list_repos
+  brn jira list_tickets
+  brn workspace switch work
+`);
+}
+// Main
+const args = process.argv.slice(2);
+const command = args[0];
+switch (command) {
+    case "start":
+        await runSkill("workflow", "start", args.slice(1));
+        break;
+    case "setup":
+        await setup();
+        break;
+    case "workspace":
+        if (args[1] === "list") {
+            await workspaceList();
+        }
+        else if (args[1] === "switch" && args[2]) {
+            await workspaceSwitch(args[2]);
+        }
+        else {
+            console.log("Usage: brn workspace [list|switch <name>]");
+        }
+        break;
+    case "help":
+    case "--help":
+    case "-h":
+    case undefined:
+        showHelp();
+        break;
+    default:
+        // Generic skill runner: brn <skill> <script> [...args]
+        if (command && args[1]) {
+            await runSkill(command, args[1], args.slice(2));
+        }
+        else {
+            console.log(`Unknown command: ${command}`);
+            showHelp();
+            process.exit(1);
+        }
+}

package/dist/lib/utils.js

@@ -0,0 +1,167 @@
+/**
+ * Shared utilities for brn scripts
+ */
+import { $ } from "zx";
+import { readFileSync, existsSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { join } from "path";
+import YAML from "yaml";
+$.verbose = false;
+/**
+ * Get the brn config from ~/.brn/config.yaml
+ */
+export function getBrnConfig() {
+    const configPath = join(homedir(), ".brn", "config.yaml");
+    if (!existsSync(configPath)) {
+        console.error("Error: No config found at ~/.brn/config.yaml");
+        console.error("Run: create_workspace.sh <name> <path>");
+        process.exit(1);
+    }
+    const content = readFileSync(configPath, "utf-8");
+    return YAML.parse(content);
+}
+/**
+ * Save the brn config to ~/.brn/config.yaml
+ */
+export function saveBrnConfig(config) {
+    const configPath = join(homedir(), ".brn", "config.yaml");
+    writeFileSync(configPath, YAML.stringify(config));
+}
+/**
+ * Update the active workspace configuration
+ */
+export function updateWorkspace(updates) {
+    const config = getBrnConfig();
+    const activeWorkspaceName = config.active_workspace;
+    if (!config.workspaces[activeWorkspaceName]) {
+        console.error(`Error: Active workspace '${activeWorkspaceName}' not found`);
+        process.exit(1);
+    }
+    config.workspaces[activeWorkspaceName] = {
+        ...config.workspaces[activeWorkspaceName],
+        ...updates,
+    };
+    saveBrnConfig(config);
+}
+/**
+ * Get the active workspace config
+ */
+export function getActiveWorkspace() {
+    const config = getBrnConfig();
+    const name = config.active_workspace;
+    const workspace = config.workspaces[name];
+    if (!workspace) {
+        console.error(`Error: Workspace '${name}' not found in config`);
+        process.exit(1);
+    }
+    return { name, ...workspace };
+}
+/**
+ * Check if an automation action is enabled for the active workspace.
+ * All automation is OFF by default for safety.
+ */
+export function isAutomationEnabled(action) {
+    const workspace = getActiveWorkspace();
+    return workspace.automation?.[action] ?? false;
+}
+/**
+ * Require automation to be enabled, or prompt user to confirm.
+ * Returns true if action should proceed, false if user declined.
+ */
+export function checkAutomation(action, description) {
+    if (isAutomationEnabled(action)) {
+        return true;
+    }
+    console.log(`⚠️  Automation disabled: ${description}`);
+    console.log(`   To enable, run: configure_workspace.sh <workspace> automation.${action} true`);
+    console.log(`   Skipping automatic execution.`);
+    return false;
+}
+/**
+ * Get GitHub token from active workspace
+ */
+export function getGitHubToken() {
+    const workspace = getActiveWorkspace();
+    if (!workspace.github_token) {
+        console.error("Error: github_token not configured for this workspace");
+        console.error(`Run: configure_workspace.sh ${workspace.name} github_token <token>`);
+        process.exit(1);
+    }
+    return workspace.github_token;
+}
+/**
+ * Get JIRA config from active workspace
+ */
+export function getJiraConfig() {
+    const workspace = getActiveWorkspace();
+    if (!workspace.jira_url) {
+        console.error("Error: jira_url not configured");
+        process.exit(1);
+    }
+    if (!workspace.jira_email) {
+        console.error("Error: jira_email not configured");
+        process.exit(1);
+    }
+    if (!workspace.jira_token) {
+        console.error("Error: jira_token not configured");
+        process.exit(1);
+    }
+    return {
+        url: workspace.jira_url.replace(/\/$/, ""),
+        email: workspace.jira_email,
+        token: workspace.jira_token,
+    };
+}
+/**
+ * Make a GitHub API request
+ */
+export async function githubRequest(endpoint, options = {}) {
+    const token = getGitHubToken();
+    console.log(`[GitHub API] Requesting: ${endpoint}`);
+    const response = await fetch(`https://api.github.com${endpoint}`, {
+        ...options,
+        headers: {
+            Authorization: `Bearer ${token}`,
+            Accept: "application/vnd.github+json",
+            "X-GitHub-Api-Version": "2022-11-28",
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error(`Error: ${response.status} - ${response.statusText}`);
+        if (error.message)
+            console.error(`  ${error.message}`);
+        process.exit(1);
+    }
+    return response.json();
+}
+/**
+ * Make a JIRA API request
+ */
+export async function jiraRequest(endpoint, options = {}) {
+    const { url, email, token } = getJiraConfig();
+    const auth = Buffer.from(`${email}:${token}`).toString("base64");
+    const response = await fetch(`${url}${endpoint}`, {
+        ...options,
+        headers: {
+            Authorization: `Basic ${auth}`,
+            Accept: "application/json",
+            "Content-Type": "application/json",
+            ...options.headers,
+        },
+    });
+    if (!response.ok) {
+        const error = await response.json().catch(() => ({}));
+        console.error(`Error: ${response.status} - ${response.statusText}`);
+        if (error.errorMessages)
+            console.error(`  ${error.errorMessages}`);
+        process.exit(1);
+    }
+    // Handle 204 No Content
+    if (response.status === 204) {
+        return {};
+    }
+    return response.json();
+}

package/dist/skills/github/scripts/create_pr.js

@@ -0,0 +1,24 @@
+#!/usr/bin/env npx tsx
+/**
+ * Create a pull request
+ * Usage: npx tsx create_pr.ts <owner/repo> <head> <base> <title> [body]
+ */
+import { githubRequest } from "../../../lib/utils.js";
+const [repoPath, head, base, title, body] = process.argv.slice(2);
+if (!repoPath || !head || !base || !title) {
+    console.log("Usage: npx tsx create_pr.ts <owner/repo> <head_branch> <base_branch> <title> [body]");
+    console.log("Example: npx tsx create_pr.ts myorg/app feature-123 main 'feat: Add feature'");
+    process.exit(1);
+}
+const pr = await githubRequest(`/repos/${repoPath}/pulls`, {
+    method: "POST",
+    body: JSON.stringify({
+        title,
+        head,
+        base,
+        body: body ?? "",
+    }),
+});
+console.log(`✓ Created PR #${pr.number}: ${pr.title}`);
+console.log(`  URL: ${pr.html_url}`);
+console.log(`  ${head} → ${base}`);

package/dist/skills/github/scripts/get_repo_info.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env npx tsx
+/**
+ * Get repository information
+ * Usage: npx tsx get_repo_info.ts <owner/repo>
+ */
+import { githubRequest } from "../../../lib/utils.js";
+const repoPath = process.argv[2];
+if (!repoPath) {
+    console.log("Usage: npx tsx get_repo_info.ts <owner/repo>");
+    console.log("Example: npx tsx get_repo_info.ts octocat/Hello-World");
+    process.exit(1);
+}
+const repo = await githubRequest(`/repos/${repoPath}`);
+console.log(`Repository: ${repo.full_name}`);
+console.log("=".repeat(50));
+console.log(`Description: ${repo.description ?? "N/A"}`);
+console.log(`Visibility:  ${repo.private ? "Private" : "Public"}`);
+console.log(`Default:     ${repo.default_branch}`);
+console.log(`Language:    ${repo.language ?? "N/A"}`);
+console.log(`Stars:       ${repo.stargazers_count}`);
+console.log(`Forks:       ${repo.forks_count}`);
+console.log(`Clone URL:   ${repo.clone_url}`);
+console.log(`SSH URL:     ${repo.ssh_url}`);

package/dist/skills/github/scripts/list_prs.js

@@ -0,0 +1,27 @@
+#!/usr/bin/env npx tsx
+/**
+ * List pull requests for a repository
+ * Usage: npx tsx list_prs.ts <owner/repo> [state]
+ */
+import { githubRequest } from "../../../lib/utils.js";
+const repoPath = process.argv[2];
+const state = process.argv[3] ?? "open";
+if (!repoPath) {
+    console.log("Usage: npx tsx list_prs.ts <owner/repo> [state]");
+    console.log("States: open, closed, all (default: open)");
+    process.exit(1);
+}
+const prs = await githubRequest(`/repos/${repoPath}/pulls?state=${state}&per_page=30`);
+console.log(`Pull Requests for ${repoPath} (${state}):`);
+console.log("=".repeat(50));
+if (prs.length === 0) {
+    console.log("No pull requests found.");
+    process.exit(0);
+}
+for (const pr of prs) {
+    const draft = pr.draft ? "📝" : "";
+    console.log(`#${pr.number} ${draft} ${pr.title}`);
+    console.log(`   ${pr.head.ref} → ${pr.base.ref} by @${pr.user.login}`);
+    console.log(`   ${pr.html_url}`);
+    console.log();
+}

package/dist/skills/github/scripts/list_repos.js

@@ -0,0 +1,39 @@
+#!/usr/bin/env npx tsx
+/**
+ * List repositories for an organization or user
+ * Usage: npx tsx list_repos.ts [org_or_user]
+ */
+import { githubRequest, getActiveWorkspace } from "../../../lib/utils.js";
+let orgOrUser = process.argv[2];
+if (!orgOrUser) {
+    const ws = getActiveWorkspace();
+    if (ws.github_org) {
+        orgOrUser = ws.github_org;
+    }
+}
+let endpoint = "/user/repos?per_page=100";
+if (orgOrUser) {
+    endpoint = `/orgs/${orgOrUser}/repos?per_page=100`;
+}
+console.log(`Fetching repositories from: ${endpoint}`);
+try {
+    let repos = await githubRequest(endpoint);
+    // If org fails, try as user
+    if (repos.length === 0 && orgOrUser) {
+        repos = await githubRequest(`/users/${orgOrUser}/repos?per_page=100`);
+    }
+    console.log(`Repositories${orgOrUser ? ` for ${orgOrUser}` : ""}:`);
+    console.log("=".repeat(50));
+    for (const repo of repos) {
+        const icon = repo.private ? "🔒" : "🌐";
+        console.log(`${icon} ${repo.full_name}`);
+        if (repo.description) {
+            console.log(`   ${repo.description.slice(0, 60)}...`);
+        }
+        console.log();
+    }
+}
+catch (error) {
+    console.error("Failed to list repositories:", error);
+    process.exit(1);
+}

package/dist/skills/jira/scripts/add_comment.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env npx tsx
+/**
+ * Add a comment to a JIRA ticket
+ * Usage: npx tsx add_comment.ts <ticket_key> <comment>
+ */
+import { jiraRequest } from "../../../lib/utils.js";
+const ticketKey = process.argv[2];
+const commentText = process.argv.slice(3).join(" ");
+if (!ticketKey || !commentText) {
+    console.log("Usage: npx tsx add_comment.ts <ticket_key> <comment>");
+    console.log("Example: npx tsx add_comment.ts PROJ-123 'PR created: https://...'");
+    process.exit(1);
+}
+// JIRA API v3 uses ADF format for comments
+const body = {
+    body: {
+        type: "doc",
+        version: 1,
+        content: [
+            {
+                type: "paragraph",
+                content: [
+                    {
+                        type: "text",
+                        text: commentText,
+                    },
+                ],
+            },
+        ],
+    },
+};
+await jiraRequest(`/rest/api/3/issue/${ticketKey}/comment`, {
+    method: "POST",
+    body: JSON.stringify(body),
+});
+console.log(`✓ Added comment to ${ticketKey}`);

package/dist/skills/jira/scripts/get_ticket.js

@@ -0,0 +1,45 @@
+#!/usr/bin/env npx tsx
+/**
+ * Get JIRA ticket details
+ * Usage: npx tsx get_ticket.ts <ticket_key>
+ */
+import { jiraRequest, getJiraConfig } from "../../../lib/utils.js";
+function extractText(node) {
+    if (typeof node !== "object" || node === null)
+        return "";
+    const obj = node;
+    if (obj.type === "text" && typeof obj.text === "string") {
+        return obj.text;
+    }
+    if (Array.isArray(obj.content)) {
+        return obj.content.map(extractText).join(" ");
+    }
+    return "";
+}
+const ticketKey = process.argv[2];
+if (!ticketKey) {
+    console.log("Usage: npx tsx get_ticket.ts <ticket_key>");
+    console.log("Example: npx tsx get_ticket.ts PROJ-123");
+    process.exit(1);
+}
+const { url } = getJiraConfig();
+const issue = await jiraRequest(`/rest/api/3/issue/${ticketKey}`);
+const { fields } = issue;
+console.log(`Ticket: ${issue.key}`);
+console.log("=".repeat(60));
+console.log(`Summary:     ${fields.summary}`);
+console.log(`Status:      ${fields.status.name}`);
+console.log(`Type:        ${fields.issuetype.name}`);
+console.log(`Priority:    ${fields.priority?.name ?? "None"}`);
+console.log(`Assignee:    ${fields.assignee?.displayName ?? "Unassigned"}`);
+console.log(`Reporter:    ${fields.reporter?.displayName ?? "Unknown"}`);
+console.log(`Created:     ${fields.created.slice(0, 10)}`);
+console.log(`Updated:     ${fields.updated.slice(0, 10)}`);
+console.log();
+if (fields.description) {
+    console.log("Description:");
+    console.log("-".repeat(40));
+    console.log(extractText(fields.description));
+}
+console.log();
+console.log(`URL: ${url}/browse/${issue.key}`);

package/dist/skills/jira/scripts/list_tickets.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env npx tsx
+/**
+ * List JIRA tickets assigned to current user
+ * Usage: npx tsx list_tickets.ts [status]
+ */
+import { jiraRequest } from "../../../lib/utils.js";
+const statusFilter = process.argv[2];
+let jql = "assignee = currentUser() ORDER BY updated DESC";
+if (statusFilter) {
+    jql = `assignee = currentUser() AND status = "${statusFilter}" ORDER BY updated DESC`;
+}
+const data = await jiraRequest("/rest/api/3/search/jql", {
+    method: "POST",
+    body: JSON.stringify({
+        jql,
+        maxResults: 20,
+        fields: ["summary", "status", "priority"],
+    }),
+});
+const issues = data.issues;
+console.log(`Your Tickets (${issues.length} found):`);
+console.log("=".repeat(60));
+if (issues.length === 0) {
+    console.log("No tickets found.");
+    process.exit(0);
+}
+const statusEmoji = {
+    "To Do": "📋",
+    "In Progress": "🔧",
+    "Code Review": "👀",
+    Done: "✅",
+};
+for (const issue of issues) {
+    const { key, fields } = issue;
+    const summary = fields.summary.slice(0, 50);
+    const status = fields.status.name;
+    const priority = fields.priority?.name ?? "None";
+    const emoji = statusEmoji[status] ?? "📌";
+    console.log(`${emoji} ${key}: ${summary}`);
+    console.log(`   Status: ${status} | Priority: ${priority}`);
+    console.log();
+}