@profoundlogic/coderflow-cli 0.2.1

package/lib/commands/run.js

@@ -0,0 +1,237 @@
+/**
+ * Command: coder run - Create and run a task
+ */
+
+import { request } from '../http-client.js';
+import { getDefaultEnvironment } from '../config.js';
+
+/**
+ * Parse command line arguments for task parameters
+ * @param {Array} args - Command line arguments
+ * @returns {Object} { taskType, environment, parameters }
+ */
+function parseKeyValue(pair) {
+  const [rawKey, ...rest] = pair.split('=');
+  if (!rawKey || rest.length === 0) {
+    return null;
+  }
+  const key = rawKey.trim();
+  const value = rest.join('=').trim();
+  if (!key || !value) {
+    return null;
+  }
+  return { key, value };
+}
+
+function parseTaskArgs(args) {
+  let taskType = null;
+  let environment = null;
+  let jiraIssueKey = null;
+  let withLocalState = false;
+  const parameters = {};
+  const envVars = {};
+  const branches = {};
+
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+
+    if (arg === '--branch') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --branch requires REPO=BRANCH or BRANCH');
+        process.exit(1);
+      }
+      const parsed = parseKeyValue(next);
+      if (parsed) {
+        // Format: --branch profoundjs=feature-xyz
+        branches[parsed.key] = parsed.value;
+      } else {
+        // Format: --branch feature-xyz (will be applied to first selectable repo)
+        branches._default = next.trim();
+      }
+      index += 1; // Skip value token
+      continue;
+    }
+
+    if (arg.startsWith('--branch=')) {
+      const pair = arg.substring('--branch='.length);
+      const parsed = parseKeyValue(pair);
+      if (parsed) {
+        // Format: --branch=profoundjs=feature-xyz
+        branches[parsed.key] = parsed.value;
+      } else {
+        // Format: --branch=feature-xyz (will be applied to first selectable repo)
+        branches._default = pair.trim();
+      }
+      continue;
+    }
+
+    if (arg === '--env') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --env requires KEY=VALUE');
+        process.exit(1);
+      }
+      const parsed = parseKeyValue(next);
+      if (!parsed) {
+        console.error(`Error: Invalid --env value: ${next}`);
+        console.error('Expected format: --env KEY=VALUE');
+        process.exit(1);
+      }
+      envVars[parsed.key] = parsed.value;
+      index += 1; // Skip value token
+      continue;
+    }
+
+    if (arg.startsWith('--env=')) {
+      const pair = arg.substring('--env='.length);
+      const parsed = parseKeyValue(pair);
+      if (!parsed) {
+        console.error(`Error: Invalid --env value: ${pair}`);
+        console.error('Expected format: --env KEY=VALUE');
+        process.exit(1);
+      }
+      envVars[parsed.key] = parsed.value;
+      continue;
+    }
+
+    if (arg === '--environment') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --environment requires a value');
+        process.exit(1);
+      }
+      environment = next;
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--environment=')) {
+      environment = arg.substring('--environment='.length);
+      continue;
+    }
+
+    if (arg === '--jira') {
+      const next = args[index + 1];
+      if (!next) {
+        console.error('Error: --jira requires an issue key (e.g., PROJ-123)');
+        process.exit(1);
+      }
+      jiraIssueKey = next.trim().toUpperCase();
+      index += 1;
+      continue;
+    }
+
+    if (arg.startsWith('--jira=')) {
+      jiraIssueKey = arg.substring('--jira='.length).trim().toUpperCase();
+      continue;
+    }
+
+    if (arg === '--with-local-state') {
+      withLocalState = true;
+      continue;
+    }
+
+    if (arg.startsWith('--')) {
+      const match = arg.match(/^--([^=]+)=(.+)$/);
+      if (match) {
+        const [, key, value] = match;
+        parameters[key] = value;
+      } else {
+        console.error(`Error: Unrecognized option: ${arg}`);
+        process.exit(1);
+      }
+      continue;
+    }
+
+    if (!taskType) {
+      taskType = arg;
+      continue;
+    }
+
+    console.error(`Error: Unexpected argument: ${arg}`);
+    process.exit(1);
+  }
+
+  return { taskType, environment, parameters, envVars, branches, jiraIssueKey, withLocalState };
+}
+
+export async function runTask(args = []) {
+  const { taskType, environment, parameters, envVars, branches, jiraIssueKey, withLocalState } = parseTaskArgs(args);
+  let resolvedEnvironment = environment;
+
+  if (!resolvedEnvironment) {
+    resolvedEnvironment = await getDefaultEnvironment();
+  }
+
+  if (jiraIssueKey) {
+    console.log(`Creating task from Jira issue: ${jiraIssueKey}`);
+    if (resolvedEnvironment) {
+      console.log(`Environment: ${resolvedEnvironment}`);
+    }
+  } else if (taskType) {
+    console.log(`Creating task: ${taskType}`);
+    if (resolvedEnvironment) {
+      console.log(`Environment: ${resolvedEnvironment}`);
+    }
+    if (Object.keys(parameters).length > 0) {
+      console.log(`Parameters: ${JSON.stringify(parameters, null, 2)}`);
+    }
+    if (Object.keys(envVars).length > 0) {
+      console.log(`Environment variables: ${JSON.stringify(envVars, null, 2)}`);
+    }
+    if (Object.keys(branches).length > 0) {
+      console.log(`Branches: ${JSON.stringify(branches, null, 2)}`);
+    }
+  } else {
+    console.log(`Creating new task...`);
+  }
+
+  const requestBody = {};
+  if (taskType) {
+    requestBody.task_type = taskType;
+  }
+  if (resolvedEnvironment) {
+    requestBody.environment = resolvedEnvironment;
+  }
+  if (Object.keys(parameters).length > 0) {
+    requestBody.parameters = parameters;
+  }
+  if (Object.keys(envVars).length > 0) {
+    requestBody.env_vars = envVars;
+  }
+  if (Object.keys(branches).length > 0) {
+    requestBody.branches = branches;
+  }
+  if (jiraIssueKey) {
+    requestBody.jira_issue_key = jiraIssueKey;
+  }
+
+  // Capture local repository state if requested
+  if (withLocalState) {
+    console.log('\n🔍 Capturing local repository state...');
+    requestBody.capture_local_state = true;
+    requestBody.source_path = process.cwd();
+  }
+
+  const data = await request('/tasks', {
+    method: 'POST',
+    body: JSON.stringify(requestBody)
+  });
+
+  console.log(`\n✓ Task created successfully`);
+  console.log(`  Task ID:      ${data.taskId}`);
+  console.log(`  Container ID: ${data.containerId}`);
+  console.log(`  Status:       ${data.status}`);
+  if (data.environment) {
+    console.log(`  Environment:  ${data.environment}`);
+  }
+  if (data.taskType) {
+    console.log(`  Task Type:    ${data.taskType}`);
+  }
+  if (data.jira) {
+    console.log(`  Jira Issue:   ${data.jira.key} - ${data.jira.summary}`);
+  }
+  console.log(`\nUse "coder status ${data.taskId}" to check progress`);
+  console.log(`Use "coder results ${data.taskId}" to get results`);
+}