Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

6.2 KB
Raw Blame
#!/usr/bin/env node
/**
 * CLI: Create a JIRA ticket using PortOS JIRA service
 *
 * Usage:
 *   node scripts/jira-create-ticket.js --app <appName> --summary "Title" [options]
 *
 * Options:
 *   --app          App name (looks up JIRA config from apps.json)
 *   --summary      Ticket summary/title (required)
 *   --description  Ticket description (defaults to summary)
 *   --type         Issue type: Task, Bug, Story, Spike (default: from app config or Task)
 *   --points       Story points (default: 1)
 *   --sprint       Use current active sprint (default: true)
 *   --no-sprint    Skip sprint assignment
 *   --epic         Epic key (CONTECH-123) or search term ("grace support") to find by name
 *   --assignee     Override assignee (default: from app config)
 *
 * Example:
 *   node scripts/jira-create-ticket.js --app portos --summary "Research MXF video" --points 1
 *   node scripts/jira-create-ticket.js --app grace --summary "Fix login" --epic "grace support"
 */

import { dirname, join } from 'path';
import { fileURLToPath } from 'url';
import fs from 'fs/promises';

const __dirname = dirname(fileURLToPath(import.meta.url));
const rootDir = join(__dirname, '..');

const jiraService = await import(join(rootDir, 'server/services/jira.js'));

function parseArgs() {
  const args = process.argv.slice(2);
  const parsed = { sprint: true, points: 1 };

  for (let i = 0; i < args.length; i++) {
    switch (args[i]) {
      case '--app': parsed.app = args[++i]; break;
      case '--summary': parsed.summary = args[++i]; break;
      case '--description': parsed.description = args[++i]; break;
      case '--type': parsed.type = args[++i]; break;
      case '--points': parsed.points = parseInt(args[++i]) || 1; break;
      case '--sprint': parsed.sprint = true; break;
      case '--no-sprint': parsed.sprint = false; break;
      case '--epic': parsed.epic = args[++i]; break;
      case '--assignee': parsed.assignee = args[++i]; break;
      case '--help': case '-h':
        console.log(`Usage: node scripts/jira-create-ticket.js --app <name> --summary "Title" [options]
  --app          App name (required, looks up JIRA config)
  --summary      Ticket title (required)
  --description  Ticket description
  --type         Issue type (Task, Bug, Story, Spike)
  --points       Story points (default: 1)
  --no-sprint    Skip sprint assignment
  --epic         Epic key (CONTECH-123) or search term ("grace support")
  --assignee     Override assignee`);
        process.exit(0);
    }
  }
  return parsed;
}

async function loadAppConfig(appName) {
  const appsFile = join(rootDir, 'data/apps.json');
  const content = await fs.readFile(appsFile, 'utf-8');
  const data = JSON.parse(content);
  const apps = Object.values(data.apps || data);

  const app = apps.find(a => a.name?.toLowerCase() === appName.toLowerCase());
  if (!app) {
    const names = apps.filter(a => a.name).map(a => a.name).join(', ');
    console.error(`❌ App "${appName}" not found. Available apps: ${names}`);
    process.exit(1);
  }

  if (!app.jira?.enabled) {
    console.error(`❌ JIRA integration not enabled for app "${appName}"`);
    process.exit(1);
  }

  return app;
}

async function getActiveSprintId(instanceId, boardId) {
  if (!boardId) return null;

  const sprints = await jiraService.getActiveSprints(instanceId, boardId);
  if (!sprints.length) {
    console.log('⚠️  No active sprints found');
    return null;
  }

  // Prefer sprint with "Sprint NN" name pattern (not ProServe etc.)
  const castSprint = sprints.find(s => /^Sprint \d+/.test(s.name));
  const sprint = castSprint || sprints[0];
  console.log(`📋 Sprint: ${sprint.name} (id: ${sprint.id})`);
  return sprint.id;
}

/**
 * Resolve an epic from either a key (CONTECH-123) or a search term ("grace support")
 */
async function resolveEpic(instanceId, projectKey, epicInput) {
  if (!epicInput) return undefined;

  // If it looks like a JIRA key (e.g. CONTECH-123), use it directly
  if (/^[A-Z]+-\d+$/.test(epicInput)) {
    console.log(`📌 Epic: ${epicInput}`);
    return epicInput;
  }

  // Otherwise search for it by name
  const epics = await jiraService.searchEpics(instanceId, projectKey, epicInput);
  if (!epics.length) {
    console.error(`⚠️  No epics found matching "${epicInput}"`);
    return undefined;
  }

  if (epics.length === 1) {
    console.log(`📌 Epic: ${epics[0].key} — ${epics[0].summary}`);
    return epics[0].key;
  }

  // Multiple matches — pick the best one (first result, most relevant)
  console.log(`📌 Epic: ${epics[0].key} — ${epics[0].summary} (${epics.length} matches, using best)`);
  return epics[0].key;
}

async function main() {
  const args = parseArgs();

  if (!args.app || !args.summary) {
    console.error('❌ --app and --summary are required. Use --help for usage.');
    process.exit(1);
  }

  const app = await loadAppConfig(args.app);
  const jira = app.jira;

  // Resolve sprint ID if needed
  let sprintId = null;
  if (args.sprint && jira.boardId) {
    sprintId = await getActiveSprintId(jira.instanceId, jira.boardId);
  }

  // Resolve epic — CLI arg overrides app config, both support search terms
  const epicKey = await resolveEpic(
    jira.instanceId,
    jira.projectKey,
    args.epic || jira.epicKey || undefined
  );

  const ticketData = {
    projectKey: jira.projectKey,
    summary: args.summary,
    description: args.description || args.summary,
    issueType: args.type || jira.issueType || 'Task',
    assignee: args.assignee || jira.assignee || undefined,
    storyPoints: args.points,
    epicKey,
    labels: jira.labels || [],
    sprintId: sprintId || undefined
  };

  console.log(`🎫 Creating ${ticketData.issueType} in ${ticketData.projectKey}...`);

  const result = await jiraService.createTicket(jira.instanceId, ticketData);

  console.log(`✅ ${result.ticketId}`);
  console.log(`🔗 ${result.url}`);
  // The sprint move happens after the create and can fail on its own — say so
  // rather than letting a ticket outside the sprint read as a clean success.
  if (result.sprint && !result.sprint.assigned) {
    console.log(`⚠️  Not added to sprint ${result.sprint.id}: ${result.sprint.error}`);
  }

  // Output JSON for programmatic use
  console.log(JSON.stringify(result));
}

main().catch(err => {
  console.error(`❌ ${err.message}`);
  process.exit(1);
});