whatnext 1.0.0

package/dist/index.js

@@ -0,0 +1,187 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import readline from "readline";
+import WebSocket from "ws";
+
+// src/config.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+var CONFIG_DIR = path.join(os.homedir(), ".whatnext");
+var CONFIG_FILE = path.join(CONFIG_DIR, "config.json");
+function loadConfig() {
+  if (!fs.existsSync(CONFIG_FILE)) {
+    throw new Error(
+      `Config file not found at ${CONFIG_FILE}. Run "whatnext login" to configure the CLI.`
+    );
+  }
+  const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
+  const config = JSON.parse(raw);
+  if (!config.api_url || !config.api_key) {
+    throw new Error(
+      `Invalid config file at ${CONFIG_FILE}. Run "whatnext login" to reconfigure.`
+    );
+  }
+  return config;
+}
+function saveConfig(config) {
+  fs.mkdirSync(CONFIG_DIR, { recursive: true });
+  fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2) + "\n");
+}
+
+// src/parse.ts
+function parseOptions(optionsStr) {
+  return optionsStr.split(",").map((s) => ({ label: s.trim() }));
+}
+function inferDecisionType(options) {
+  return options ? "select" : "free_text";
+}
+function parseMetadata(metadataStr) {
+  if (!metadataStr) return void 0;
+  try {
+    return JSON.parse(metadataStr);
+  } catch {
+    throw new Error(`Invalid JSON in --metadata: ${metadataStr}`);
+  }
+}
+
+// src/index.ts
+function prompt(question, defaultValue) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stderr
+  });
+  const suffix = defaultValue ? ` (${defaultValue})` : "";
+  return new Promise((resolve) => {
+    rl.question(`${question}${suffix}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue || "");
+    });
+  });
+}
+var program = new Command();
+program.name("whatnext").description("Human-in-the-loop decision routing for coding agents");
+program.command("login").description("Configure the CLI with API URL and key").action(async () => {
+  try {
+    const apiUrl = await prompt("API URL", "http://localhost:3001");
+    const apiKey = await prompt("API Key");
+    if (!apiKey) {
+      console.error("API key is required.");
+      process.exit(1);
+    }
+    saveConfig({ api_url: apiUrl, api_key: apiKey });
+    console.error("Configuration saved successfully.");
+  } catch (err) {
+    console.error("Login failed:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("ask").description("Send a decision request and wait for a response").requiredOption("--message <text>", "Decision message").option("--options <items>", "Comma-separated options (makes it a select type)").option("--ttl <duration>", "Time-to-live", "10m").option("--metadata <json>", "JSON metadata").action(async (opts) => {
+  try {
+    const config = loadConfig();
+    const type = inferDecisionType(opts.options);
+    const metadata = parseMetadata(opts.metadata);
+    const body = {
+      message: opts.message,
+      type,
+      ttl: opts.ttl,
+      ...metadata && { metadata },
+      ...type === "select" && { options: parseOptions(opts.options) }
+    };
+    const res = await fetch(`${config.api_url}/api/decisions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.api_key}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      console.error(`API error (${res.status}): ${text}`);
+      process.exit(1);
+    }
+    const decision = await res.json();
+    const wsUrl = `${config.api_url.replace("http", "ws")}/ws?decision_id=${decision.id}`;
+    const ws = new WebSocket(wsUrl, {
+      headers: { Authorization: `Bearer ${config.api_key}` }
+    });
+    console.error(`Waiting for response... (expires in ${opts.ttl})`);
+    ws.on("message", (data) => {
+      try {
+        const msg = JSON.parse(data.toString());
+        if (msg.type === "decision_response") {
+          const payload = msg.payload;
+          const label = payload.selected_option?.label;
+          const text = payload.text;
+          if (label && text) {
+            console.log(`${label}: ${text}`);
+          } else if (label) {
+            console.log(label);
+          } else if (text) {
+            console.log(text);
+          }
+          ws.close();
+          process.exit(0);
+        }
+        if (msg.type === "decision_expired") {
+          console.error("Decision expired");
+          ws.close();
+          process.exit(1);
+        }
+        if (msg.type === "error") {
+          console.error("Server error:", JSON.stringify(msg.payload));
+          ws.close();
+          process.exit(1);
+        }
+      } catch (parseErr) {
+        console.error("Failed to parse WebSocket message:", parseErr);
+        ws.close();
+        process.exit(1);
+      }
+    });
+    ws.on("error", (err) => {
+      console.error("WebSocket error:", err.message);
+      process.exit(1);
+    });
+    ws.on("close", (code, reason) => {
+      if (code !== 1e3) {
+        console.error(`WebSocket closed unexpectedly (code ${code}): ${reason.toString()}`);
+        process.exit(1);
+      }
+    });
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.command("notify").description("Send a fire-and-forget notification").requiredOption("--message <text>", "Notification message").option("--metadata <json>", "JSON metadata").action(async (opts) => {
+  try {
+    const config = loadConfig();
+    const metadata = parseMetadata(opts.metadata);
+    const body = {
+      message: opts.message,
+      ...metadata && { metadata }
+    };
+    const res = await fetch(`${config.api_url}/api/notifications`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${config.api_key}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const text = await res.text();
+      console.error(`API error (${res.status}): ${text}`);
+      process.exit(1);
+    }
+    console.error("Notification sent");
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+    process.exit(1);
+  }
+});
+program.parse();

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "whatnext",
+  "version": "1.0.0",
+  "description": "Human-in-the-loop decision routing for coding agents",
+  "type": "module",
+  "bin": {
+    "whatnext": "dist/index.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "test": "vitest run"
+  },
+  "dependencies": {
+    "commander": "^13.0.0",
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.5.0",
+    "@types/node": "^22.0.0",
+    "@whatnext/shared": "*",
+    "tsup": "^8.0.0",
+    "tsx": "^4.19.0",
+    "typescript": "^5.7.0",
+    "vitest": "^3.0.0"
+  },
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/marcussanatan/whatnext.git",
+    "directory": "packages/cli"
+  },
+  "keywords": [
+    "cli",
+    "human-in-the-loop",
+    "agent",
+    "decision",
+    "coding-agent"
+  ]
+}