workplane 0.1.2 → 0.3.0

package/README.md

@@ -1,5 +1,6 @@
 # workplane
 
+[![website](https://img.shields.io/badge/website-mindstaq.github.io%2Fworkplane-3dd6c6)](https://mindstaq.github.io/workplane/)
 [![npm version](https://img.shields.io/npm/v/workplane)](https://www.npmjs.com/package/workplane)
 [![status](https://img.shields.io/badge/status-beta-orange)](https://github.com/MindStaq/workplane)
 [![license](https://img.shields.io/npm/l/workplane)](https://github.com/MindStaq/workplane/blob/main/packages/workplane/LICENSE)

package/dist/cli.js

@@ -1,4 +1,110 @@
 #!/usr/bin/env node
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// ../workplans/src/providers/anthropic.ts
+var anthropic_exports = {};
+__export(anthropic_exports, {
+  runAnthropicStep: () => runAnthropicStep
+});
+import Anthropic from "@anthropic-ai/sdk";
+async function runAnthropicStep(opts) {
+  const client = new Anthropic({ apiKey: opts.apiKey ?? process.env.ANTHROPIC_API_KEY });
+  const message = await client.messages.create({
+    model: opts.model,
+    max_tokens: 4096,
+    messages: [{ role: "user", content: opts.prompt }]
+  });
+  const block = message.content[0];
+  return block.type === "text" ? block.text : "";
+}
+var init_anthropic = __esm({
+  "../workplans/src/providers/anthropic.ts"() {
+    "use strict";
+  }
+});
+
+// ../workplans/src/providers/openai.ts
+var openai_exports = {};
+__export(openai_exports, {
+  runOpenAIStep: () => runOpenAIStep
+});
+import OpenAI from "openai";
+async function runOpenAIStep(opts) {
+  const client = new OpenAI({ apiKey: opts.apiKey ?? process.env.OPENAI_API_KEY });
+  const completion = await client.chat.completions.create({
+    model: opts.model,
+    messages: [{ role: "user", content: opts.prompt }]
+  });
+  return completion.choices[0]?.message.content ?? "";
+}
+var init_openai = __esm({
+  "../workplans/src/providers/openai.ts"() {
+    "use strict";
+  }
+});
+
+// ../workplans/src/providers/ollama.ts
+var ollama_exports = {};
+__export(ollama_exports, {
+  runOllamaStep: () => runOllamaStep
+});
+import { Ollama } from "ollama";
+async function runOllamaStep(opts) {
+  const host = opts.host ?? process.env.OLLAMA_HOST ?? "http://localhost:11434";
+  const client = new Ollama({ host });
+  const response = await client.generate({ model: opts.model, prompt: opts.prompt });
+  return response.response;
+}
+var init_ollama = __esm({
+  "../workplans/src/providers/ollama.ts"() {
+    "use strict";
+  }
+});
+
+// ../workplans/src/providers/shell.ts
+var shell_exports = {};
+__export(shell_exports, {
+  runShellStep: () => runShellStep
+});
+import { exec } from "child_process";
+import { promisify } from "util";
+async function runShellStep(opts) {
+  const { stdout } = await execAsync(opts.command, {
+    cwd: opts.cwd,
+    maxBuffer: 10 * 1024 * 1024
+  });
+  return stdout;
+}
+var execAsync;
+var init_shell = __esm({
+  "../workplans/src/providers/shell.ts"() {
+    "use strict";
+    execAsync = promisify(exec);
+  }
+});
+
+// ../workplans/src/providers/file.ts
+var file_exports = {};
+__export(file_exports, {
+  runFileStep: () => runFileStep
+});
+import { readFile } from "fs/promises";
+async function runFileStep(opts) {
+  return readFile(opts.path, opts.encoding ?? "utf8");
+}
+var init_file = __esm({
+  "../workplans/src/providers/file.ts"() {
+    "use strict";
+  }
+});
 
 // ../core/src/env.ts
 import { config as dotenvConfig } from "dotenv";
@@ -64,6 +170,292 @@ async function workplaneFetch(serverUrl2, path, options = {}) {
   return await response.json();
 }
 
+// ../agent-skills/src/skills/code-review.ts
+function codeReviewPlan(opts = {}) {
+  const { repoPath = ".", model = "claude-haiku-4-5-20251001", branch } = opts;
+  const diffCmd = branch ? `git diff ${branch}..HEAD` : "git diff HEAD~1";
+  return {
+    id: "code-review",
+    name: "Code Review",
+    steps: [
+      {
+        id: "diff",
+        name: "Git Diff",
+        adapter: "shell",
+        provider: "shell",
+        payload: { command: diffCmd, cwd: repoPath },
+        output: { dest: "next" }
+      },
+      {
+        id: "summarize",
+        name: "Summarize",
+        adapter: "ollama",
+        provider: "ollama",
+        model: "llama3",
+        payload: { prompt: "Summarize these code changes concisely:\n{{prevOutput}}" },
+        output: { dest: "next" }
+      },
+      {
+        id: "critique",
+        name: "Critique",
+        adapter: "anthropic",
+        provider: "anthropic",
+        model,
+        payload: { prompt: "Review this summary for correctness, security issues, and code quality:\n{{prevOutput}}" }
+      }
+    ]
+  };
+}
+
+// ../agent-skills/src/skills/summarize-file.ts
+function summarizeFilePlan(opts) {
+  const { filePath, provider = "ollama", model = "llama3" } = opts;
+  return {
+    id: "summarize-file",
+    name: "Summarize File",
+    steps: [
+      {
+        id: "read",
+        name: "Read File",
+        adapter: "file",
+        provider: "file",
+        payload: { path: filePath },
+        output: { dest: "next" }
+      },
+      {
+        id: "summarize",
+        name: "Summarize",
+        adapter: provider,
+        provider,
+        model,
+        payload: { prompt: "Summarize the following file content concisely:\n{{prevOutput}}" }
+      }
+    ]
+  };
+}
+
+// ../agent-skills/src/skills/index.ts
+var SkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  register(entry) {
+    this.skills.set(entry.name, entry);
+  }
+  get(name) {
+    return this.skills.get(name);
+  }
+  list() {
+    return Array.from(this.skills.values());
+  }
+};
+function createDefaultRegistry() {
+  const registry = new SkillRegistry();
+  registry.register({
+    name: "code-review",
+    description: "Git diff \u2192 local summarize (ollama) \u2192 frontier critique (anthropic)",
+    buildPlan: (opts) => codeReviewPlan({
+      repoPath: typeof opts.repo === "string" ? opts.repo : void 0,
+      model: typeof opts.model === "string" ? opts.model : void 0,
+      branch: typeof opts.branch === "string" ? opts.branch : void 0
+    })
+  });
+  registry.register({
+    name: "summarize-file",
+    description: "Read file \u2192 summarize with configurable provider (default: ollama)",
+    buildPlan: (opts) => {
+      const filePath = typeof opts.file === "string" ? opts.file : "";
+      if (!filePath) throw new Error("--file is required for summarize-file");
+      return summarizeFilePlan({
+        filePath,
+        provider: typeof opts.provider === "string" ? opts.provider : void 0,
+        model: typeof opts.model === "string" ? opts.model : void 0
+      });
+    }
+  });
+  return registry;
+}
+function listSkills(registry) {
+  for (const skill of registry.list()) {
+    process.stdout.write(`  ${skill.name.padEnd(20)} ${skill.description}
+`);
+  }
+}
+
+// ../workplans/src/template.ts
+function applyTemplate(payload, prevOutput) {
+  return Object.fromEntries(
+    Object.entries(payload).map(([k, v]) => [
+      k,
+      typeof v === "string" ? v.replaceAll("{{prevOutput}}", prevOutput) : v
+    ])
+  );
+}
+
+// ../workplans/src/runner.ts
+var INLINE_PROVIDERS = /* @__PURE__ */ new Set(["anthropic", "openai", "ollama", "shell", "file"]);
+async function runInlineStep(step, prompt) {
+  const provider = step.provider;
+  if (provider === "anthropic") {
+    const { runAnthropicStep: runAnthropicStep2 } = await Promise.resolve().then(() => (init_anthropic(), anthropic_exports));
+    return runAnthropicStep2({ model: step.model ?? "claude-haiku-4-5-20251001", prompt });
+  }
+  if (provider === "openai") {
+    const { runOpenAIStep: runOpenAIStep2 } = await Promise.resolve().then(() => (init_openai(), openai_exports));
+    return runOpenAIStep2({ model: step.model ?? "gpt-4o-mini", prompt });
+  }
+  if (provider === "ollama") {
+    const { runOllamaStep: runOllamaStep2 } = await Promise.resolve().then(() => (init_ollama(), ollama_exports));
+    return runOllamaStep2({ model: step.model ?? "llama3", prompt });
+  }
+  if (provider === "shell") {
+    const { runShellStep: runShellStep2 } = await Promise.resolve().then(() => (init_shell(), shell_exports));
+    return runShellStep2({
+      command: String(step.payload.command ?? ""),
+      cwd: typeof step.payload.cwd === "string" ? step.payload.cwd : void 0
+    });
+  }
+  if (provider === "file") {
+    const { runFileStep: runFileStep2 } = await Promise.resolve().then(() => (init_file(), file_exports));
+    return runFileStep2({ path: String(step.payload.path ?? "") });
+  }
+  throw new Error(`unknown inline provider: ${provider}`);
+}
+var SequentialWorkplanRunner = class {
+  async run(plan, ctx) {
+    const results = [];
+    let prevOutput = "";
+    let planSucceeded = true;
+    for (const step of plan.steps) {
+      const payload = prevOutput ? applyTemplate(step.payload, prevOutput) : step.payload;
+      const prompt = typeof payload.prompt === "string" ? payload.prompt : "";
+      const start = Date.now();
+      let output = "";
+      let exitCode = 0;
+      try {
+        if (step.provider && INLINE_PROVIDERS.has(step.provider)) {
+          output = await runInlineStep({ ...step, payload }, prompt);
+        } else {
+          const node = await ctx.resolveNode(step.requires ?? [], step.provider);
+          const result = await node.execute({ ...step, payload });
+          output = result.output;
+          exitCode = result.exitCode;
+        }
+      } catch (err) {
+        exitCode = 1;
+        output = err instanceof Error ? err.message : String(err);
+        planSucceeded = false;
+        const stepResult2 = {
+          stepId: step.id,
+          output,
+          exitCode,
+          durationMs: Date.now() - start
+        };
+        results.push(stepResult2);
+        ctx.emitResult(step.id, step.name, output);
+        if (!step.continueOnError) {
+          return {
+            planId: plan.id,
+            status: "step_failed",
+            steps: results,
+            succeeded: false
+          };
+        }
+        prevOutput = "";
+        continue;
+      }
+      const dest = step.output?.dest ?? "stdout";
+      const stepResult = {
+        stepId: step.id,
+        output,
+        exitCode,
+        durationMs: Date.now() - start
+      };
+      results.push(stepResult);
+      if (dest === "stdout" || dest === "artifact") {
+        ctx.emitResult(step.id, step.name, output);
+        prevOutput = "";
+      } else if (dest === "next") {
+        prevOutput = output;
+      }
+    }
+    return {
+      planId: plan.id,
+      status: planSucceeded ? "completed" : "failed",
+      steps: results,
+      succeeded: planSucceeded
+    };
+  }
+};
+
+// ../workplans/src/sinks/stdout.ts
+function printStepResult(stepName, output) {
+  process.stdout.write(`=== step: ${stepName} ===
+${output}
+
+`);
+}
+
+// ../workplans/src/context.ts
+var WorkplaneNodeHandle = class {
+  constructor(serverUrl2, nodeToken) {
+    this.serverUrl = serverUrl2;
+    this.nodeToken = nodeToken;
+  }
+  serverUrl;
+  nodeToken;
+  async execute(step) {
+    const start = Date.now();
+    const taskRes = await fetch(`${this.serverUrl}/tasks`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        authorization: `Bearer ${this.nodeToken}`
+      },
+      body: JSON.stringify({
+        kind: "workplan.step",
+        adapter: step.adapter,
+        payload: step.payload,
+        requires: step.requires ?? []
+      })
+    });
+    if (!taskRes.ok) {
+      throw new Error(`failed to submit step ${step.id}: ${taskRes.status}`);
+    }
+    const task = await taskRes.json();
+    const output = await this.pollUntilDone(task.id);
+    return { stepId: step.id, output, exitCode: 0, durationMs: Date.now() - start };
+  }
+  async pollUntilDone(taskId) {
+    const terminalStatuses = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled"]);
+    for (; ; ) {
+      await new Promise((r) => setTimeout(r, 1e3));
+      const res = await fetch(`${this.serverUrl}/tasks/${taskId}`, {
+        headers: { authorization: `Bearer ${this.nodeToken}` }
+      });
+      const task = await res.json();
+      if (terminalStatuses.has(task.status)) {
+        if (task.status !== "succeeded") {
+          throw new Error(`step task ${taskId} ended with status: ${task.status}`);
+        }
+        return typeof task.payload?.output === "string" ? task.payload.output : "";
+      }
+    }
+  }
+};
+var LocalWorkplanContext = class {
+  serverUrl;
+  nodeToken;
+  constructor(opts = {}) {
+    this.serverUrl = opts.serverUrl ?? process.env.WORKPLANE_SERVER_URL ?? "http://localhost:8787";
+    this.nodeToken = opts.nodeToken ?? process.env.WORKPLANE_NODE_TOKEN ?? "";
+  }
+  async resolveNode(_requires, _provider) {
+    return new WorkplaneNodeHandle(this.serverUrl, this.nodeToken);
+  }
+  emitResult(_stepId, stepName, output) {
+    printStepResult(stepName, output);
+  }
+};
+
 // ../cli/src/index.ts
 loadLocalEnv();
 var serverUrl = process.env.WORKPLANE_SERVER_URL ?? "http://localhost:8787";
@@ -111,13 +503,18 @@ function usage() {
       "  task submit shell --command <cmd> [--repo <url>] [--branch <b>] [--cwd <path>]",
       "  task submit aider --prompt <text> --repo <url> [--model <m>] [--test-command <cmd>]",
       "  task submit inference --model <m> --prompt <text> [--requires ollama]",
-      "  task submit harness --harness <codex|claude-code> --repo <url> --prompt <text>",
+      "  task submit harness --harness <codex|claude-code> --repo <url> --prompt <text> [--interactive]",
       "  tasks [--status <status>]",
       "  task show|logs|retry|cancel <taskId>",
       "  runs [--task-id <id>] [--status <status>]",
       "  run show <runId>",
+      "  run input <runId> --stdin <text>",
+      "  run input <runId> --signal <SIGTERM|SIGKILL|SIGINT>",
+      "  run input <runId> --resize <COLSxROWS>",
       "  logs <runId|taskId>",
-      "  artifacts <runId>"
+      "  artifacts <runId>",
+      "  skill list",
+      "  skill run <name> [--key value ...]"
     ].join("\n")
   );
 }
@@ -201,6 +598,7 @@ async function submitHarness(args) {
   const model = valueArg(args, "--model");
   const branch = valueArg(args, "--branch");
   const testCommand = valueArg(args, "--test-command");
+  const interactive = args.includes("--interactive") || void 0;
   const requires = parseCsv(valueArg(args, "--requires") ?? `${harness},git`);
   const task = await httpJson("/tasks", {
     method: "POST",
@@ -209,7 +607,7 @@ async function submitHarness(args) {
       kind: "agent.run",
       adapter: harness,
       requires,
-      payload: { prompt, repo, model, branch, testCommand }
+      payload: { prompt, repo, model, branch, testCommand, interactive }
     }
   });
   printJson(task);
@@ -304,6 +702,36 @@ async function main() {
     printJson(runs);
     return;
   }
+  if (command === "run" && subcommand === "input") {
+    const runId = rest[0];
+    if (!runId) {
+      throw new Error("run id is required");
+    }
+    const inputArgs = rest.slice(1);
+    const stdinData = valueArg(inputArgs, "--stdin");
+    const signal = valueArg(inputArgs, "--signal");
+    const resize = valueArg(inputArgs, "--resize");
+    let body;
+    if (stdinData !== void 0) {
+      body = { kind: "stdin", payload: { data: stdinData } };
+    } else if (signal !== void 0) {
+      if (signal !== "SIGTERM" && signal !== "SIGKILL" && signal !== "SIGINT") {
+        throw new Error("--signal must be SIGTERM, SIGKILL, or SIGINT");
+      }
+      body = { kind: "signal", payload: { signal } };
+    } else if (resize !== void 0) {
+      const match = /^(\d+)x(\d+)$/.exec(resize);
+      if (!match) {
+        throw new Error("--resize must be in COLSxROWS format, e.g. 220x50");
+      }
+      body = { kind: "resize", payload: { cols: Number(match[1]), rows: Number(match[2]) } };
+    } else {
+      throw new Error("one of --stdin, --signal, or --resize is required");
+    }
+    const result = await httpJson(`/runs/${runId}/input`, { method: "POST", operator: true, body });
+    printJson(result);
+    return;
+  }
   if (command === "run" && subcommand === "show") {
     const runId = rest[0];
     if (!runId) {
@@ -330,6 +758,41 @@ async function main() {
     printJson(artifacts);
     return;
   }
+  if (command === "skill" && subcommand === "list") {
+    const registry = createDefaultRegistry();
+    process.stdout.write("Available skills:\n");
+    listSkills(registry);
+    return;
+  }
+  if (command === "skill" && subcommand === "run") {
+    const skillName = rest[0];
+    if (!skillName) {
+      throw new Error("skill name is required");
+    }
+    const registry = createDefaultRegistry();
+    const skill = registry.get(skillName);
+    if (!skill) {
+      throw new Error(`unknown skill: ${skillName}. Run 'workplane skill list' to see available skills.`);
+    }
+    const optArgs = rest.slice(1);
+    const options = {};
+    for (let i = 0; i < optArgs.length - 1; i++) {
+      if (optArgs[i].startsWith("--")) {
+        options[optArgs[i].slice(2)] = optArgs[i + 1];
+        i++;
+      }
+    }
+    const plan = skill.buildPlan(options);
+    const runner = new SequentialWorkplanRunner();
+    const ctx = new LocalWorkplanContext();
+    const result = await runner.run(plan, ctx);
+    if (!result.succeeded) {
+      process.stderr.write(`skill '${skillName}' failed at step '${result.steps.at(-1)?.stepId ?? "unknown"}'
+`);
+      process.exit(1);
+    }
+    return;
+  }
   usage();
 }
 main().catch((error) => {