@astroanywhere/cli 0.2.0 → 0.2.2

package/dist/index.js

@@ -6,8 +6,9 @@ import {
   loadConfig,
   resetConfig,
   saveConfig,
+  streamChatToStdout,
   streamDispatchToStdout
-} from "./chunk-7H7WD7QX.js";
+} from "./chunk-MJRAJPBU.js";
 
 // src/index.ts
 import { Command } from "commander";
@@ -128,6 +129,74 @@ function formatStatus(status) {
   return colorFn(status);
 }
 
+// src/chat-utils.ts
+import { readFileSync, writeFileSync } from "fs";
+import { createInterface } from "readline";
+var MAX_HISTORY_MESSAGES = 100;
+function loadHistory(path) {
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const messages = JSON.parse(raw);
+    if (!Array.isArray(messages)) return [];
+    return messages.slice(-MAX_HISTORY_MESSAGES);
+  } catch {
+    return [];
+  }
+}
+function saveHistory(path, messages) {
+  writeFileSync(path, JSON.stringify(messages.slice(-MAX_HISTORY_MESSAGES), null, 2));
+}
+async function promptApproval(question, options) {
+  process.stderr.write(`
+${question}
+`);
+  for (let i = 0; i < options.length; i++) {
+    process.stderr.write(`  [${i + 1}] ${options[i]}
+`);
+  }
+  process.stderr.write("Select option (number): ");
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve) => {
+    rl.question("", (input) => {
+      rl.close();
+      const idx = parseInt(input.trim(), 10) - 1;
+      if (idx >= 0 && idx < options.length) {
+        resolve({ answered: true, answer: options[idx] });
+      } else {
+        resolve({ answered: false });
+      }
+    });
+  });
+}
+function createApprovalHandler(client, yolo) {
+  return async (data) => {
+    let result;
+    if (yolo) {
+      result = { answered: true, answer: data.options[0] };
+      process.stderr.write(`
+[yolo] Auto-approved: ${data.question} \u2192 ${data.options[0]}
+`);
+    } else {
+      result = await promptApproval(data.question, data.options);
+    }
+    if (data.taskId && data.machineId && data.requestId) {
+      try {
+        await client.sendApproval({
+          taskId: data.taskId,
+          machineId: data.machineId,
+          requestId: data.requestId,
+          answered: result.answered,
+          answer: result.answer
+        });
+      } catch (err) {
+        process.stderr.write(`[approval] Failed to send: ${err instanceof Error ? err.message : String(err)}
+`);
+      }
+    }
+    return result;
+  };
+}
+
 // src/commands/project.ts
 import chalk2 from "chalk";
 var projectColumns = [
@@ -165,7 +234,6 @@ function registerProjectCommands(program2) {
       ["Status", formatStatus(p.status)],
       ["Description", p.description || chalk2.dim("\u2014")],
       ["Working Directory", p.workingDirectory || chalk2.dim("\u2014")],
-      ["Source Directory", p.sourceDirectory || chalk2.dim("\u2014")],
       ["Repository", p.repository || chalk2.dim("\u2014")],
       ["Delivery Mode", p.deliveryMode || chalk2.dim("\u2014")],
       ["Health", p.health || chalk2.dim("\u2014")],
@@ -311,6 +379,62 @@ function registerProjectCommands(program2) {
       process.exitCode = 1;
     }
   });
+  project.command("chat <id>").description("Chat with AI about a project").requiredOption("--message <msg>", "Message to send").option("--session-id <sid>", "Resume existing session").option("--model <model>", "AI model to use").option("--provider <provider>", "Provider ID").option("--history-file <path>", "Path to conversation history JSON file").option("--yolo", "Auto-approve all approval requests").action(async (id, cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    let p;
+    try {
+      p = await client.resolveProject(id);
+    } catch (err) {
+      console.error(chalk2.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    let planNodes = [];
+    let planEdges = [];
+    try {
+      const plan = await client.getPlan(p.id);
+      planNodes = plan.nodes.filter((n) => !n.deletedAt);
+      planEdges = plan.edges;
+    } catch {
+    }
+    let messages = [];
+    if (cmdOpts.historyFile) {
+      messages = loadHistory(cmdOpts.historyFile);
+    }
+    try {
+      const response = await client.projectChat({
+        message: cmdOpts.message,
+        projectId: p.id,
+        sessionId: cmdOpts.sessionId,
+        model: cmdOpts.model,
+        providerId: cmdOpts.provider,
+        visionDoc: p.visionDoc || void 0,
+        planNodes,
+        planEdges,
+        messages: messages.length > 0 ? messages : void 0
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      const result = await streamChatToStdout(response, {
+        json: opts.json,
+        onApprovalRequest: approvalHandler
+      });
+      if (result.sessionId) {
+        process.stderr.write(`
+${chalk2.dim(`Session: ${result.sessionId}`)}
+`);
+      }
+      if (cmdOpts.historyFile && result.assistantText) {
+        messages.push({ role: "user", content: cmdOpts.message });
+        messages.push({ role: "assistant", content: result.assistantText });
+        saveHistory(cmdOpts.historyFile, messages);
+      }
+      console.log();
+    } catch (err) {
+      console.error(chalk2.red(`Chat failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
   project.command("delete <id>").description("Delete a project").action(async (id) => {
     const opts = program2.opts();
     const client = getClient(opts.serverUrl);
@@ -675,6 +799,35 @@ function registerPlanCommands(program2) {
         process.exitCode = 1;
     }
   });
+  plan.command("generate").description("Generate a plan using AI").requiredOption("--project-id <id>", "Project ID").requiredOption("--description <desc>", "Description of what to plan").option("--model <model>", "AI model to use").option("--provider <provider>", "Preferred provider ID").option("--machine <id>", "Target machine ID").option("--yolo", "Auto-approve all approval requests").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    console.log(chalk3.dim("Generating plan..."));
+    console.log();
+    try {
+      const response = await client.dispatchTask({
+        nodeId: `plan-${cmdOpts.projectId}`,
+        projectId: cmdOpts.projectId,
+        title: `Interactive planning: ${cmdOpts.description.slice(0, 80)}`,
+        isInteractivePlan: true,
+        description: cmdOpts.description,
+        verification: "human",
+        model: cmdOpts.model,
+        preferredProvider: cmdOpts.provider,
+        targetMachineId: cmdOpts.machine
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      await streamDispatchToStdout(response, {
+        json: opts.json,
+        onApprovalRequest: approvalHandler
+      });
+      console.log();
+      console.log(chalk3.green("Plan generation complete."));
+    } catch (err) {
+      console.error(chalk3.red(`Plan generation failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
 }
 
 // src/commands/task.ts
@@ -860,17 +1013,54 @@ function registerTaskCommands(program2) {
     }
     console.log();
   });
-  cmd.command("dispatch <id>").description("Dispatch a task for execution").requiredOption("--project-id <id>", "Project ID").option("--force", "Force re-dispatch even if already running").action(async (nodeId, opts) => {
+  cmd.command("dispatch <id>").description("Dispatch a task for execution").requiredOption("--project-id <id>", "Project ID").option("--force", "Force re-dispatch even if already running").option("--machine <id>", "Target machine ID").option("--model <model>", "AI model to use").option("--provider <provider>", "Preferred provider ID").option("--yolo", "Auto-approve all approval requests").option("--slurm", "Dispatch to Slurm cluster").option("--slurm-partition <p>", "Slurm partition").option("--slurm-gpus <n>", "Number of GPUs", parseInt).option("--slurm-gpu-type <t>", "GPU type (e.g. a100, v100)").option("--slurm-mem <m>", "Memory (e.g. 16G, 64G)").option("--slurm-time <t>", "Time limit (e.g. 1:00:00)").option("--slurm-nodes <n>", "Number of nodes", parseInt).option("--slurm-cpus <n>", "CPUs per task", parseInt).option("--slurm-qos <q>", "Quality of service").option("--slurm-account <a>", "Slurm account").option("--slurm-modules <m>", "Comma-separated modules to load").option("--cluster <id>", "Target Slurm cluster ID").action(async (nodeId, opts) => {
     const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
     console.log(chalk4.dim(`Dispatching task ${chalk4.bold(nodeId)} to server...`));
     console.log();
     try {
+      if (opts.slurm) {
+        const slurmConfig = {};
+        if (opts.slurmPartition) slurmConfig.partition = opts.slurmPartition;
+        if (opts.slurmNodes) slurmConfig.nodes = opts.slurmNodes;
+        if (opts.slurmCpus) slurmConfig.cpusPerTask = opts.slurmCpus;
+        if (opts.slurmMem) slurmConfig.mem = opts.slurmMem;
+        if (opts.slurmTime) slurmConfig.time = opts.slurmTime;
+        if (opts.slurmQos) slurmConfig.qos = opts.slurmQos;
+        if (opts.slurmAccount) slurmConfig.account = opts.slurmAccount;
+        if (opts.slurmModules) slurmConfig.modules = opts.slurmModules.split(",").map((s) => s.trim());
+        if (opts.slurmGpus || opts.slurmGpuType) {
+          slurmConfig.gpu = { count: opts.slurmGpus ?? 1, type: opts.slurmGpuType };
+        }
+        const response2 = await client.dispatchSlurmTask({
+          task: {
+            taskId: `exec-${nodeId}-${Date.now()}`,
+            projectId: opts.projectId,
+            nodeId,
+            title: nodeId,
+            preferredProvider: opts.provider
+          },
+          targetClusterId: opts.cluster,
+          slurmConfig: Object.keys(slurmConfig).length > 0 ? slurmConfig : void 0
+        });
+        await streamDispatchToStdout(response2, { json: isJson });
+        console.log();
+        console.log(chalk4.green("Slurm dispatch complete."));
+        return;
+      }
+      const approvalHandler = createApprovalHandler(client, !!opts.yolo);
       const response = await client.dispatchTask({
         nodeId,
         projectId: opts.projectId,
-        force: opts.force
+        force: opts.force,
+        targetMachineId: opts.machine,
+        model: opts.model,
+        preferredProvider: opts.provider
+      });
+      await streamDispatchToStdout(response, {
+        json: isJson,
+        onApprovalRequest: approvalHandler
       });
-      await streamDispatchToStdout(response);
       console.log();
       console.log(chalk4.green("Task dispatch complete."));
     } catch (err) {
@@ -878,6 +1068,70 @@ function registerTaskCommands(program2) {
       process.exitCode = 1;
     }
   });
+  cmd.command("chat <nodeId>").description("Chat with AI about a specific task").requiredOption("--project-id <id>", "Project ID").requiredOption("--message <msg>", "Message to send").option("--session-id <sid>", "Resume existing session").option("--model <model>", "AI model to use").option("--provider <provider>", "Provider ID").option("--history-file <path>", "Path to conversation history JSON file").option("--yolo", "Auto-approve all approval requests").action(async (nodeId, cmdOpts) => {
+    const client = getClient(program2.opts().serverUrl);
+    const isJson = program2.opts().json;
+    let node;
+    try {
+      const { nodes } = await client.getPlan(cmdOpts.projectId);
+      node = nodes.find((n) => n.id === nodeId && !n.deletedAt);
+    } catch (err) {
+      console.error(chalk4.red(err.message));
+      process.exitCode = 1;
+      return;
+    }
+    if (!node) {
+      console.error(chalk4.red(`Task not found: ${nodeId}`));
+      process.exitCode = 1;
+      return;
+    }
+    let visionDoc;
+    try {
+      const project = await client.getProject(cmdOpts.projectId);
+      visionDoc = project.visionDoc || void 0;
+    } catch {
+    }
+    let messages = [];
+    if (cmdOpts.historyFile) {
+      messages = loadHistory(cmdOpts.historyFile);
+    }
+    try {
+      const response = await client.taskChat({
+        message: cmdOpts.message,
+        nodeId,
+        projectId: cmdOpts.projectId,
+        taskTitle: node.title,
+        taskDescription: node.description || void 0,
+        taskOutput: node.executionOutput || void 0,
+        visionDoc,
+        sessionId: cmdOpts.sessionId,
+        model: cmdOpts.model,
+        providerId: cmdOpts.provider,
+        branchName: node.branchName || void 0,
+        prUrl: node.prUrl || void 0,
+        messages: messages.length > 0 ? messages : void 0
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      const result = await streamChatToStdout(response, {
+        json: isJson,
+        onApprovalRequest: approvalHandler
+      });
+      if (result.sessionId) {
+        process.stderr.write(`
+${chalk4.dim(`Session: ${result.sessionId}`)}
+`);
+      }
+      if (cmdOpts.historyFile && result.assistantText) {
+        messages.push({ role: "user", content: cmdOpts.message });
+        messages.push({ role: "assistant", content: result.assistantText });
+        saveHistory(cmdOpts.historyFile, messages);
+      }
+      console.log();
+    } catch (err) {
+      console.error(chalk4.red(`Chat failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
   cmd.command("cancel <executionId>").description("Cancel a running task execution").option("--machine <id>", "Target machine ID").option("--node-id <id>", "Node ID").action(async (executionId, opts) => {
     const client = getClient(program2.opts().serverUrl);
     const isJson = program2.opts().json;
@@ -947,9 +1201,10 @@ function registerTaskCommands(program2) {
       process.exitCode = 1;
     }
   });
-  cmd.command("watch <executionId>").description("Watch real-time output from a running task via SSE").action(async (executionId) => {
+  cmd.command("watch <executionId>").description("Watch real-time output from a running task via SSE").option("--yolo", "Auto-approve all approval requests").action(async (executionId, cmdOpts) => {
     const client = getClient(program2.opts().serverUrl);
     const isJson = program2.opts().json;
+    const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
     try {
       const response = await client.streamEvents();
       if (!response.body) {
@@ -994,6 +1249,17 @@ ${chalk4.bold("--- Result:")} ${formatStatus(event.status ?? "unknown")} ${event
               case "task:stdout":
                 process.stdout.write(event.data ?? "");
                 break;
+              case "task:approval_request": {
+                const result = await approvalHandler({
+                  requestId: event.requestId,
+                  question: event.question,
+                  options: event.options,
+                  machineId: event.machineId,
+                  taskId: event.taskId
+                });
+                void result;
+                break;
+              }
             }
           } catch {
           }
@@ -2074,6 +2340,43 @@ function registerCompletionCommands(program2) {
   });
 }
 
+// src/commands/playground.ts
+import chalk11 from "chalk";
+function registerPlaygroundCommands(program2) {
+  const playground = program2.command("playground").description("Run ephemeral AI executions");
+  playground.command("start").description("Start a playground execution").requiredOption("--project-id <id>", "Project ID").requiredOption("--description <desc>", "What to execute").option("--dir <path>", "Working directory override").option("--model <model>", "AI model to use").option("--provider <provider>", "Preferred provider ID").option("--machine <id>", "Target machine ID").option("--yolo", "Auto-approve all approval requests").action(async (cmdOpts) => {
+    const opts = program2.opts();
+    const client = getClient(opts.serverUrl);
+    const nodeId = `playground-${cmdOpts.projectId}-${Date.now()}`;
+    console.log(chalk11.dim(`Starting playground execution ${chalk11.bold(nodeId)}...`));
+    console.log();
+    try {
+      const response = await client.dispatchTask({
+        nodeId,
+        projectId: cmdOpts.projectId,
+        skipSafetyCheck: true,
+        description: cmdOpts.description,
+        title: "Playground execution",
+        model: cmdOpts.model,
+        preferredProvider: cmdOpts.provider,
+        targetMachineId: cmdOpts.machine,
+        ...cmdOpts.dir ? { workingDirectory: cmdOpts.dir } : {}
+      });
+      const approvalHandler = createApprovalHandler(client, !!cmdOpts.yolo);
+      await streamDispatchToStdout(response, {
+        json: opts.json,
+        onApprovalRequest: approvalHandler
+      });
+      console.log();
+      console.log(chalk11.green("Playground execution complete."));
+      console.log(chalk11.dim(`For follow-up: astro-cli task chat ${nodeId} --project-id ${cmdOpts.projectId} --message "..."`));
+    } catch (err) {
+      console.error(chalk11.red(`Playground failed: ${err instanceof Error ? err.message : String(err)}`));
+      process.exitCode = 1;
+    }
+  });
+}
+
 // src/index.ts
 var program = new Command();
 program.name("astro-cli").description("CLI for managing Astro projects, plans, tasks, and environments").version("0.2.0").option("--json", "Machine-readable JSON output").option("--quiet", "Suppress spinners and decorative output").option("--server-url <url>", "Override server URL");
@@ -2087,6 +2390,7 @@ registerEnvCommands(program);
 registerConfigCommands(program);
 registerAuthCommands(program);
 registerCompletionCommands(program);
+registerPlaygroundCommands(program);
 program.command("tui").description("Launch interactive terminal UI").action(async () => {
   const { launchTui } = await import("./tui.js");
   await launchTui(program.opts().serverUrl);