overlord-cli 0.2605101225.0

package/bin/_cli/new-ticket.mjs

@@ -0,0 +1,306 @@
+#!/usr/bin/env node
+
+import readline from 'node:readline';
+import { stdin as input, stdout as output } from 'node:process';
+
+import { buildAuthHeaders, resolveAuth } from './credentials.mjs';
+import { runLauncherCommand } from './launcher.mjs';
+
+const PROMPT_AGENT_IDENTIFIERS = {
+  claude: 'claude-code',
+  codex: 'codex',
+  cursor: 'cursor',
+  gemini: 'gemini',
+  opencode: 'opencode'
+};
+const PROMPT_AGENTS = Object.keys(PROMPT_AGENT_IDENTIFIERS);
+
+function parseFlags(args) {
+  const flags = {};
+  const positionals = [];
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (!arg.startsWith('--')) {
+      positionals.push(arg);
+      continue;
+    }
+
+    const eqIdx = arg.indexOf('=');
+    if (eqIdx !== -1) {
+      flags[arg.slice(2, eqIdx)] = arg.slice(eqIdx + 1);
+      continue;
+    }
+
+    const key = arg.slice(2);
+    if (i + 1 < args.length && !args[i + 1].startsWith('--')) {
+      flags[key] = args[i + 1];
+      i++;
+    } else {
+      flags[key] = true;
+    }
+  }
+
+  return { flags, positionals };
+}
+
+function buildUsage(commandName) {
+  if (commandName === 'prompt') {
+    return 'Usage: ovld prompt "<objective>" [--title "..."] [--acceptance-criteria "..."] [--available-tools "..."] [--execution-target agent|human] [--priority low|medium|high|urgent] [--project-id <id>] [--agent <agent>] [--model <identifier>] [--delegate <agent>]';
+  }
+
+  return 'Usage: ovld create "<objective>" [--title "..."] [--acceptance-criteria "..."] [--available-tools "..."] [--execution-target agent|human] [--priority low|medium|high|urgent] [--project-id <id>] [--agent <agent>] [--model <identifier>] [--delegate <agent>]';
+}
+
+function ensureObjective(commandName, objective) {
+  if (objective) return;
+
+  console.error(`Error: objective is required.\n`);
+  console.error(buildUsage(commandName));
+  process.exit(1);
+}
+
+export function parseNumberedSelection(rawValue, count) {
+  const trimmed = rawValue.trim();
+  if (!trimmed) return null;
+  if (!/^\d+$/.test(trimmed)) return null;
+
+  const selected = Number.parseInt(trimmed, 10);
+  if (selected < 1 || selected > count) return null;
+
+  return selected - 1;
+}
+
+export function sortProjects(projects) {
+  return [...projects].sort((left, right) => {
+    const byOrganization = String(left.organizationName ?? '').localeCompare(
+      String(right.organizationName ?? '')
+    );
+    if (byOrganization !== 0) return byOrganization;
+
+    const byName = String(left.name ?? '').localeCompare(String(right.name ?? ''));
+    if (byName !== 0) return byName;
+
+    return String(left.id ?? '').localeCompare(String(right.id ?? ''));
+  });
+}
+
+function projectLabel(project) {
+  const organizationName = String(project.organizationName ?? '').trim();
+  return organizationName ? `${project.name} - ${organizationName}` : project.name;
+}
+
+async function promptForSelection({ items, label, prompt, renderItem }) {
+  if (!items.length) {
+    throw new Error(`No ${label.toLowerCase()} available.`);
+  }
+
+  const rl = readline.createInterface({ input, output });
+  const question = promptText =>
+    new Promise((resolve, reject) => {
+      const handleError = error => {
+        rl.off('error', handleError);
+        reject(error);
+      };
+
+      rl.once('error', handleError);
+      rl.question(promptText, answer => {
+        rl.off('error', handleError);
+        resolve(answer);
+      });
+    });
+
+  try {
+    while (true) {
+      output.write(`\n${label}\n`);
+      items.forEach((item, index) => {
+        output.write(`  ${index + 1}. ${renderItem(item, index)}\n`);
+      });
+
+      const answer = await question(`\n${prompt} `);
+      const selectedIndex = parseNumberedSelection(answer, items.length);
+      if (selectedIndex !== null) {
+        return items[selectedIndex];
+      }
+
+      output.write(`Enter a number between 1 and ${items.length}.\n`);
+    }
+  } finally {
+    rl.close();
+  }
+}
+
+async function fetchProjects(platformUrl, bearerToken, localSecret, organizationId) {
+  const res = await fetch(`${platformUrl}/api/protocol/projects`, {
+    headers: buildAuthHeaders(bearerToken, localSecret, organizationId)
+  });
+
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(
+      `Failed to list projects (${res.status}): ${data.error ?? JSON.stringify(data)}`
+    );
+  }
+
+  return Array.isArray(data.projects) ? sortProjects(data.projects) : [];
+}
+
+async function createTicket(platformUrl, bearerToken, localSecret, organizationId, body) {
+  const res = await fetch(`${platformUrl}/api/protocol/tickets`, {
+    method: 'POST',
+    headers: {
+      ...buildAuthHeaders(bearerToken, localSecret, organizationId),
+      'Content-Type': 'application/json'
+    },
+    body: JSON.stringify(body)
+  });
+
+  const data = await res.json().catch(() => ({}));
+  if (!res.ok) {
+    throw new Error(
+      `Failed to create ticket (${res.status}): ${data.error ?? JSON.stringify(data)}`
+    );
+  }
+
+  return data.ticket;
+}
+
+function resolveProject(projects, projectId) {
+  if (!projectId) return null;
+
+  const project = projects.find(candidate => candidate.id === projectId);
+  if (!project) {
+    throw new Error(`Unknown project ID: ${projectId}`);
+  }
+
+  return project;
+}
+
+function resolveAgent(agent) {
+  if (!agent) return null;
+
+  const normalizedAgent = agent.trim().toLowerCase();
+  if (!PROMPT_AGENTS.includes(normalizedAgent)) {
+    throw new Error(`Unknown agent: "${agent}". Must be one of: ${PROMPT_AGENTS.join(', ')}`);
+  }
+
+  return normalizedAgent;
+}
+
+export function resolvePromptAgentIdentifier(agent) {
+  return PROMPT_AGENT_IDENTIFIERS[agent] ?? agent;
+}
+
+export function resolveTicketCreationModelIdentifier(flags = {}) {
+  const explicitModel = typeof flags.model === 'string' ? flags.model.trim() : '';
+  if (explicitModel) return explicitModel;
+
+  const envModel =
+    process.env.OVERLORD_MODEL_IDENTIFIER?.trim() ||
+    process.env.MODEL_IDENTIFIER?.trim() ||
+    process.env.AGENT_MODEL?.trim();
+  return envModel || null;
+}
+
+export function resolveTicketCreationDelegate(flags = {}, selectedAgent = null, modelIdentifier = '') {
+  const explicitDelegate = typeof flags.delegate === 'string' ? flags.delegate.trim() : '';
+  if (explicitDelegate) return explicitDelegate;
+
+  const resolvedModel = typeof modelIdentifier === 'string' ? modelIdentifier.trim() : '';
+  if (resolvedModel) return resolvedModel;
+
+  const explicitAgent = typeof flags.agent === 'string' ? flags.agent.trim() : '';
+  if (explicitAgent) return resolvePromptAgentIdentifier(explicitAgent.toLowerCase()) ?? explicitAgent;
+
+  if (selectedAgent) return resolvePromptAgentIdentifier(selectedAgent);
+
+  const envAgent = process.env.AGENT_IDENTIFIER?.trim();
+  return envAgent || null;
+}
+
+async function runTicketCreationFlow(args, { commandName, launchAgent }) {
+  const { flags, positionals } = parseFlags(args);
+  const objective = String(flags.objective ?? positionals.join(' ')).trim();
+  ensureObjective(commandName, objective);
+
+  const { platformUrl, bearerToken, localSecret, organizationId } = await resolveAuth();
+  const projects = await fetchProjects(platformUrl, bearerToken, localSecret, organizationId);
+
+  if (!projects.length) {
+    throw new Error('No projects available. Create a project first.');
+  }
+
+  const selectedProject =
+    resolveProject(projects, typeof flags['project-id'] === 'string' ? flags['project-id'] : '') ??
+    (await promptForSelection({
+      items: projects,
+      label: 'Projects',
+      prompt: 'Select a project by number:',
+      renderItem: project => projectLabel(project)
+    }));
+
+  const selectedAgent = launchAgent
+    ? (resolveAgent(typeof flags.agent === 'string' ? flags.agent : '') ??
+      (await promptForSelection({
+        items: PROMPT_AGENTS,
+        label: 'Agents',
+        prompt: 'Select an agent by number:',
+        renderItem: agent => agent
+      })))
+    : null;
+
+  const modelIdentifier = resolveTicketCreationModelIdentifier(flags);
+  const ticketDelegate = resolveTicketCreationDelegate(flags, selectedAgent, modelIdentifier);
+
+  const ticket = await createTicket(platformUrl, bearerToken, localSecret, organizationId, {
+    objective,
+    title: String(flags.title ?? ''),
+    acceptanceCriteria: String(flags['acceptance-criteria'] ?? ''),
+    availableTools: String(flags['available-tools'] ?? ''),
+    executionTarget: String(flags['execution-target'] ?? 'agent'),
+    priority: String(flags.priority ?? 'medium'),
+    projectId: selectedProject.id,
+    ...(ticketDelegate ? { delegate: ticketDelegate } : {})
+  });
+
+  if (!launchAgent) {
+    console.log(`ticket created with id ${ticket.id}`);
+    return;
+  }
+
+  process.env.TICKET_ID = ticket.id;
+  await runLauncherCommand('run', [selectedAgent, '--ticket-id', ticket.id]);
+}
+
+export async function runCreateCommand(args) {
+  if (args[0] === '--help' || args[0] === 'help') {
+    console.log(`${buildUsage('create')}
+
+Creates a ticket after interactive numbered project selection.
+
+Examples:
+  ovld create "Implement login page" --agent codex
+  ovld create "Fix sync bug" --project-id <project-id>
+`);
+    return;
+  }
+
+  await runTicketCreationFlow(args, { commandName: 'create', launchAgent: false });
+}
+
+export async function runPromptCommand(args) {
+  if (args[0] === '--help' || args[0] === 'help') {
+    console.log(`${buildUsage('prompt')}
+
+Creates a ticket after interactive numbered project selection, then lets you pick an agent by number and launches it on the new ticket.
+
+Examples:
+  ovld prompt "Implement login page"
+  ovld prompt "Investigate flaky tests" --agent codex --model gpt-5.4
+`);
+    return;
+  }
+
+  await runTicketCreationFlow(args, { commandName: 'prompt', launchAgent: true });
+}

package/bin/_cli/postinstall.mjs

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+
+/**
+ * Post-install message for Overlord CLI
+ * Shown after `npm install -g overlord-cli` or `yarn global add overlord-cli`
+ */
+
+import { fileURLToPath } from 'node:url';
+import { dirname } from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+// Only show message if this is a global install (not local dev)
+const isGlobalInstall = process.env.npm_config_global === 'true' ||
+                        process.env.npm_execpath?.includes('yarn') ||
+                        !__dirname.includes('node_modules');
+
+if (!isGlobalInstall) {
+  process.exit(0);
+}
+
+const green = s => `\x1b[32m${s}\x1b[0m`;
+const cyan = s => `\x1b[36m${s}\x1b[0m`;
+const bold = s => `\x1b[1m${s}\x1b[0m`;
+
+console.log(`
+${green('✓')} Overlord CLI installed successfully!
+
+${bold('Next step:')} Prepare agent plugins and connectors
+
+  ${cyan('ovld setup')}
+
+This will guide you through:
+  • Selecting which agent plugins/connectors to prepare (Claude, Cursor, etc.)
+  • Migrating Claude from the v3.25 connector files to the v4 plugin
+  • Configuring agent permissions for Overlord protocol access
+
+You can also run ${cyan('ovld setup <agent>')} to prepare a specific agent,
+or ${cyan('ovld doctor')} to check your installation status.
+
+Run ${cyan('ovld help')} to see all available commands.
+`);