vibe-coding-master 0.8.13 → 0.9.0

package/dist/backend/templates/harness/node-tool-runtime.js

@@ -0,0 +1,102 @@
+// Shared JavaScript source embedded in Node harness tools. Installed tools run
+// standalone, so each rendered tool carries its own copy. The source avoids
+// backticks and "${" so it can be embedded in template literals unchanged.
+export function renderNodeToolHeader(description) {
+    return `#!/usr/bin/env node
+"use strict";
+// ${description}
+`;
+}
+// parseToolArguments(argv, spec) mirrors the argparse behavior the tools rely on:
+// long options as "--name value" or "--name=value", required options, choices,
+// repeatable options, flags, positionals, and usage errors that exit with 2.
+export const NODE_TOOL_ARGUMENT_PARSER = String.raw `
+function parseToolArguments(argv, spec) {
+  const prog = require("node:path").basename(process.argv[1] || "tool");
+  const options = spec.options || {};
+  const positionals = spec.positionals || [];
+  const usage = "usage: " + prog
+    + Object.keys(options).map((name) => " [" + name + (options[name].flag ? "" : " " + name.slice(2).toUpperCase()) + "]").join("")
+    + positionals.map((name) => " " + name).join("");
+  const fail = (message) => {
+    process.stderr.write(usage + "\n" + prog + ": error: " + message + "\n");
+    process.exit(2);
+  };
+  const values = {};
+  for (const [name, option] of Object.entries(options)) {
+    values[option.dest] = option.append ? [] : option.flag ? false : option.default;
+  }
+  const remaining = [];
+  for (let index = 0; index < argv.length; index += 1) {
+    const argument = argv[index];
+    if (argument === "-h" || argument === "--help") {
+      process.stdout.write(usage + "\n\n" + (spec.description || "") + "\n");
+      process.exit(0);
+    }
+    if (!argument.startsWith("--") || argument === "--") {
+      remaining.push(argument);
+      continue;
+    }
+    const separator = argument.indexOf("=");
+    const name = separator >= 0 ? argument.slice(0, separator) : argument;
+    const option = options[name];
+    if (!option) {
+      fail("unrecognized arguments: " + argument);
+    }
+    if (option.flag) {
+      values[option.dest] = true;
+      continue;
+    }
+    let value;
+    if (separator >= 0) {
+      value = argument.slice(separator + 1);
+    } else {
+      if (index + 1 >= argv.length) {
+        fail("argument " + name + ": expected one argument");
+      }
+      index += 1;
+      value = argv[index];
+    }
+    if (option.choices && !option.choices.includes(value)) {
+      fail("argument " + name + ": invalid choice: '" + value + "' (choose from " + option.choices.map((choice) => "'" + choice + "'").join(", ") + ")");
+    }
+    if (option.append) {
+      values[option.dest].push(value);
+    } else {
+      values[option.dest] = value;
+    }
+  }
+  if (remaining.length > positionals.length) {
+    fail("unrecognized arguments: " + remaining.slice(positionals.length).join(" "));
+  }
+  positionals.forEach((name, index) => {
+    values[name] = remaining[index];
+  });
+  const missing = [
+    ...positionals.filter((name) => values[name] === undefined),
+    ...Object.entries(options).filter(([, option]) => option.required && values[option.dest] === undefined).map(([name]) => name)
+  ];
+  if (missing.length > 0) {
+    fail("the following arguments are required: " + missing.join(", "));
+  }
+  return values;
+}
+`;
+// postJson(url, body, timeoutMs) returns { ok, status, statusText, text } or
+// throws on network failure or timeout, like urllib.request.urlopen.
+export const NODE_TOOL_HTTP = String.raw `
+async function postJson(url, body, timeoutMs) {
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+    signal: AbortSignal.timeout(timeoutMs)
+  });
+  return { ok: response.ok, status: response.status, statusText: response.statusText, text: await response.text() };
+}
+
+function networkErrorText(error) {
+  const cause = error && error.cause;
+  return (cause && (cause.message || cause.code)) || (error && error.message) || String(error);
+}
+`;

package/dist/backend/templates/harness/resolve-durable-doc-assignment.js

@@ -1,60 +1,54 @@
+import { NODE_TOOL_ARGUMENT_PARSER, NODE_TOOL_HTTP, renderNodeToolHeader } from "./node-tool-runtime.js";
 export function renderResolveDurableDocAssignmentTool() {
-    return `#!/usr/bin/env python3
-import argparse
-import json
-import os
-import sys
-import urllib.error
-import urllib.request
-
-
-def emit(status, message=None):
-    payload = {"status": status}
-    if message:
-        payload["message"] = message
-    print(json.dumps(payload, ensure_ascii=False))
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Assign a VCM durable-document update to a workflow role.")
-    parser.add_argument("--assignment", required=True)
-    parser.add_argument("--owner", required=True, choices=["architect", "coder", "tester"])
-    args = parser.parse_args()
-
-    if os.environ.get("VCM_ROLE") != "project-manager":
-        emit("rejected", "Only project-manager may resolve a durable-document owner.")
-        return 2
-
-    api_url = os.environ.get("VCM_API_URL", "").rstrip("/")
-    task_slug = os.environ.get("VCM_TASK_SLUG", "").strip()
-    if not api_url or not task_slug:
-        emit("rejected", "VCM_API_URL or VCM_TASK_SLUG is unavailable.")
-        return 2
-
-    request = urllib.request.Request(
-        api_url + "/api/projects/harness/memory/assignments/owner",
-        data=json.dumps({
-            "taskSlug": task_slug,
-            "assignmentId": args.assignment,
-            "owner": args.owner,
-        }).encode("utf-8"),
-        headers={"content-type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(request, timeout=5):
-            pass
-        emit("accepted")
-        return 0
-    except urllib.error.HTTPError as error:
-        detail = error.read().decode("utf-8", errors="replace")
-        emit("rejected", f"VCM rejected the owner: HTTP {error.code} {detail}")
-    except (OSError, ValueError, urllib.error.URLError) as error:
-        emit("failed", f"VCM could not record the owner: {error}")
-    return 2
+    return String.raw `${renderNodeToolHeader("Assign a VCM durable-document update to a workflow role.")}${NODE_TOOL_ARGUMENT_PARSER}${NODE_TOOL_HTTP}
+function emit(status, message) {
+  const payload = { status };
+  if (message) {
+    payload.message = message;
+  }
+  process.stdout.write(JSON.stringify(payload) + "\n");
+}
 
+async function main() {
+  const args = parseToolArguments(process.argv.slice(2), {
+    description: "Assign a VCM durable-document update to a workflow role.",
+    options: {
+      "--assignment": { dest: "assignment", required: true },
+      "--owner": { dest: "owner", required: true, choices: ["architect", "coder", "tester"] }
+    }
+  });
+
+  if (process.env.VCM_ROLE !== "project-manager") {
+    emit("rejected", "Only project-manager may resolve a durable-document owner.");
+    return 2;
+  }
+
+  const apiUrl = (process.env.VCM_API_URL || "").replace(/\/+$/, "");
+  const taskSlug = (process.env.VCM_TASK_SLUG || "").trim();
+  if (!apiUrl || !taskSlug) {
+    emit("rejected", "VCM_API_URL or VCM_TASK_SLUG is unavailable.");
+    return 2;
+  }
+
+  let response;
+  try {
+    response = await postJson(apiUrl + "/api/projects/harness/memory/assignments/owner", {
+      taskSlug,
+      assignmentId: args.assignment,
+      owner: args.owner
+    }, 5000);
+  } catch (error) {
+    emit("failed", "VCM could not record the owner: " + networkErrorText(error));
+    return 2;
+  }
+  if (!response.ok) {
+    emit("rejected", "VCM rejected the owner: HTTP " + response.status + " " + response.text);
+    return 2;
+  }
+  emit("accepted");
+  return 0;
+}
 
-if __name__ == "__main__":
-    sys.exit(main())
+main().then((code) => process.exit(code));
 `;
 }

package/dist/backend/templates/harness/restart-architect-skill.js

@@ -1,3 +1,4 @@
+import { NODE_TOOL_HTTP, renderNodeToolHeader } from "./node-tool-runtime.js";
 export function renderRestartArchitectSkillRules() {
     return `## Purpose
 
@@ -23,67 +24,57 @@ Then write the completed Architect-to-PM route message and end the turn. VCM kee
 Do not use this skill for incomplete planning, user clarification, Debug Mode, Architecture Diagnosis Mode, or docs sync.`;
 }
 export function renderRequestArchitectRestartTool() {
-    return `#!/usr/bin/env python3
-import json
-import os
-import sys
-import urllib.error
-import urllib.parse
-import urllib.request
-
-
-def emit(status, **fields):
-    payload = {"status": status, **fields}
-    print(json.dumps(payload, ensure_ascii=False))
-
-
-def main():
-    if os.environ.get("VCM_ROLE") != "architect":
-        emit("rejected", message="Only architect may schedule the post-planning restart.")
-        return 2
+    return String.raw `${renderNodeToolHeader("Schedule the Architect post-planning restart.")}${NODE_TOOL_HTTP}
+function emit(status, fields) {
+  process.stdout.write(JSON.stringify({ status, ...(fields || {}) }) + "\n");
+}
 
-    api_url = os.environ.get("VCM_API_URL", "").rstrip("/")
-    task_slug = os.environ.get("VCM_TASK_SLUG", "").strip()
-    if not api_url or not task_slug:
-        emit("rejected", message="VCM_API_URL or VCM_TASK_SLUG is unavailable.")
-        return 2
+async function main() {
+  if (process.env.VCM_ROLE !== "architect") {
+    emit("rejected", { message: "Only architect may schedule the post-planning restart." });
+    return 2;
+  }
 
-    url = (
-        api_url
-        + "/api/tasks/"
-        + urllib.parse.quote(task_slug, safe="")
-        + "/sessions/architect/restart-after-planning"
-    )
-    request = urllib.request.Request(
-        url,
-        data=b"{}",
-        headers={"content-type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(request, timeout=5) as response:
-            payload = json.loads(response.read().decode("utf-8"))
-        emit(
-            payload.get("status", "scheduled"),
-            taskSlug=task_slug,
-            sessionId=payload.get("sessionId"),
-            memoryCandidatePath=payload.get("memoryCandidatePath"),
-        )
-        return 0
-    except urllib.error.HTTPError as error:
-        try:
-            payload = json.loads(error.read().decode("utf-8"))
-            message = payload.get("error", {}).get("message", str(error))
-        except Exception:
-            message = str(error)
-        emit("rejected", message=message)
-        return 2
-    except (OSError, ValueError, urllib.error.URLError) as error:
-        emit("failed", message=str(error))
-        return 2
+  const apiUrl = (process.env.VCM_API_URL || "").replace(/\/+$/, "");
+  const taskSlug = (process.env.VCM_TASK_SLUG || "").trim();
+  if (!apiUrl || !taskSlug) {
+    emit("rejected", { message: "VCM_API_URL or VCM_TASK_SLUG is unavailable." });
+    return 2;
+  }
 
+  const url = apiUrl + "/api/tasks/" + encodeURIComponent(taskSlug) + "/sessions/architect/restart-after-planning";
+  let response;
+  try {
+    response = await postJson(url, {}, 5000);
+  } catch (error) {
+    emit("failed", { message: networkErrorText(error) });
+    return 2;
+  }
+  if (!response.ok) {
+    let message = "HTTP Error " + response.status + ": " + response.statusText;
+    try {
+      const payload = JSON.parse(response.text);
+      message = (payload.error && payload.error.message) || message;
+    } catch {
+      // Keep the HTTP status message when the error body is not JSON.
+    }
+    emit("rejected", { message });
+    return 2;
+  }
+  try {
+    const payload = JSON.parse(response.text);
+    emit(payload.status || "scheduled", {
+      taskSlug,
+      sessionId: payload.sessionId ?? null,
+      memoryCandidatePath: payload.memoryCandidatePath ?? null
+    });
+    return 0;
+  } catch (error) {
+    emit("failed", { message: error.message });
+    return 2;
+  }
+}
 
-if __name__ == "__main__":
-    sys.exit(main())
+main().then((code) => process.exit(code));
 `;
 }

package/dist/backend/templates/harness/vcm-ask-user-skill.js

@@ -1,3 +1,4 @@
+import { NODE_TOOL_ARGUMENT_PARSER, NODE_TOOL_HTTP, renderNodeToolHeader } from "./node-tool-runtime.js";
 export function renderVcmAskUserSkillRules() {
     return `## Purpose
 
@@ -17,66 +18,63 @@ Every question pauses the workflow. PM may defer a question by not asking it; on
 `;
 }
 export function renderAskUserTool() {
-    return `#!/usr/bin/env python3
-import argparse
-import json
-import os
-import sys
-import urllib.error
-import urllib.parse
-import urllib.request
-
-
-def emit(status, message=None, state=None):
-    payload = {"status": status}
-    if message:
-        payload["message"] = message
-    if state is not None:
-        payload["state"] = state
-    print(json.dumps(payload, ensure_ascii=False))
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Pause VCM workflow for an exact user question.")
-    parser.add_argument("--question", required=True)
-    args = parser.parse_args()
-
-    if os.environ.get("VCM_ROLE") != "project-manager":
-        emit("failed", "Only project-manager may ask the user through VCM workflow control.")
-        return 2
-
-    question = args.question.strip()
-    if not question:
-        emit("failed", "A non-empty user question is required.")
-        return 2
-
-    api_url = os.environ.get("VCM_API_URL", "").rstrip("/")
-    task_slug = os.environ.get("VCM_TASK_SLUG", "").strip()
-    if not api_url or not task_slug:
-        emit("failed", "VCM_API_URL or VCM_TASK_SLUG is unavailable; the workflow was not paused.")
-        return 2
-
-    url = f"{api_url}/api/tasks/{urllib.parse.quote(task_slug, safe='')}/ask-user"
-    request = urllib.request.Request(
-        url,
-        data=json.dumps({"question": question}).encode("utf-8"),
-        headers={"content-type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(request, timeout=5) as response:
-            state = json.loads(response.read().decode("utf-8"))
-        emit("awaiting_user", state=state)
-        return 0
-    except urllib.error.HTTPError as error:
-        detail = error.read().decode("utf-8", errors="replace")
-        emit("failed", f"VCM rejected the user question: HTTP {error.code} {detail}")
-    except (OSError, ValueError, urllib.error.URLError) as error:
-        emit("failed", f"VCM could not register the user question: {error}")
-    return 1
+    return String.raw `${renderNodeToolHeader("Pause VCM workflow for an exact user question.")}${NODE_TOOL_ARGUMENT_PARSER}${NODE_TOOL_HTTP}
+function emit(status, message, state) {
+  const payload = { status };
+  if (message) {
+    payload.message = message;
+  }
+  if (state !== undefined) {
+    payload.state = state;
+  }
+  process.stdout.write(JSON.stringify(payload) + "\n");
+}
 
+async function main() {
+  const args = parseToolArguments(process.argv.slice(2), {
+    description: "Pause VCM workflow for an exact user question.",
+    options: { "--question": { dest: "question", required: true } }
+  });
+
+  if (process.env.VCM_ROLE !== "project-manager") {
+    emit("failed", "Only project-manager may ask the user through VCM workflow control.");
+    return 2;
+  }
+
+  const question = args.question.trim();
+  if (!question) {
+    emit("failed", "A non-empty user question is required.");
+    return 2;
+  }
+
+  const apiUrl = (process.env.VCM_API_URL || "").replace(/\/+$/, "");
+  const taskSlug = (process.env.VCM_TASK_SLUG || "").trim();
+  if (!apiUrl || !taskSlug) {
+    emit("failed", "VCM_API_URL or VCM_TASK_SLUG is unavailable; the workflow was not paused.");
+    return 2;
+  }
+
+  const url = apiUrl + "/api/tasks/" + encodeURIComponent(taskSlug) + "/ask-user";
+  let response;
+  try {
+    response = await postJson(url, { question }, 5000);
+  } catch (error) {
+    emit("failed", "VCM could not register the user question: " + networkErrorText(error));
+    return 1;
+  }
+  if (!response.ok) {
+    emit("failed", "VCM rejected the user question: HTTP " + response.status + " " + response.text);
+    return 1;
+  }
+  try {
+    emit("awaiting_user", undefined, JSON.parse(response.text));
+    return 0;
+  } catch (error) {
+    emit("failed", "VCM could not register the user question: " + error.message);
+    return 1;
+  }
+}
 
-if __name__ == "__main__":
-    sys.exit(main())
+main().then((code) => process.exit(code));
 `;
 }

package/dist/backend/templates/harness/vcm-task-state-skill.js

@@ -1,3 +1,4 @@
+import { NODE_TOOL_ARGUMENT_PARSER, NODE_TOOL_HTTP, renderNodeToolHeader } from "./node-tool-runtime.js";
 export function renderVcmTaskStateSkillRules() {
     return `## Purpose
 
@@ -21,79 +22,72 @@ If declaration fails, report the warning when relevant and continue the existing
 `;
 }
 export function renderUpdateTaskStateTool() {
-    return `#!/usr/bin/env python3
-import argparse
-import json
-import os
-import sys
-import urllib.error
-import urllib.parse
-import urllib.request
-
-
-def emit(status, message=None, state=None):
-    payload = {"status": status}
-    if message:
-        payload["message"] = message
-    if state is not None:
-        payload["state"] = state
-    print(json.dumps(payload, ensure_ascii=False))
-
-
-def main():
-    parser = argparse.ArgumentParser(description="Declare advisory VCM task workflow state.")
-    parser.add_argument("--flow")
-    parser.add_argument("--step")
-    parser.add_argument("--branch")
-    parser.add_argument("--resume-point")
-    parser.add_argument("--status")
-    parser.add_argument("--evidence", action="append", default=[])
-    args = parser.parse_args()
-
-    if os.environ.get("VCM_ROLE") != "project-manager":
-        emit("warning", "Only project-manager may declare VCM task workflow state.")
-        return 0
-
-    api_url = os.environ.get("VCM_API_URL", "").rstrip("/")
-    task_slug = os.environ.get("VCM_TASK_SLUG", "").strip()
-    if not api_url or not task_slug:
-        emit("warning", "VCM_API_URL or VCM_TASK_SLUG is unavailable; task state was not updated.")
-        return 0
-
-    payload = {}
-    for key, value in (
-        ("flow", args.flow),
-        ("step", args.step),
-        ("branch", args.branch),
-        ("resumePoint", args.resume_point),
-        ("status", args.status),
-    ):
-        if value is not None:
-            payload[key] = value
-    if args.evidence:
-        payload["evidenceRefs"] = args.evidence
-
-    if not payload:
-        emit("warning", "No task workflow fields were supplied.")
-        return 0
-
-    url = f"{api_url}/api/tasks/{urllib.parse.quote(task_slug, safe='')}/workflow-state"
-    request = urllib.request.Request(
-        url,
-        data=json.dumps(payload).encode("utf-8"),
-        headers={"content-type": "application/json"},
-        method="POST",
-    )
-    try:
-        with urllib.request.urlopen(request, timeout=3) as response:
-            state = json.loads(response.read().decode("utf-8"))
-        emit("updated", state=state)
-    except (OSError, ValueError, urllib.error.URLError, urllib.error.HTTPError) as error:
-        emit("warning", f"Task state was not updated: {error}")
-    return 0
+    return String.raw `${renderNodeToolHeader("Declare advisory VCM task workflow state.")}${NODE_TOOL_ARGUMENT_PARSER}${NODE_TOOL_HTTP}
+function emit(status, message, state) {
+  const payload = { status };
+  if (message) {
+    payload.message = message;
+  }
+  if (state !== undefined) {
+    payload.state = state;
+  }
+  process.stdout.write(JSON.stringify(payload) + "\n");
+}
 
+async function main() {
+  const args = parseToolArguments(process.argv.slice(2), {
+    description: "Declare advisory VCM task workflow state.",
+    options: {
+      "--flow": { dest: "flow" },
+      "--step": { dest: "step" },
+      "--branch": { dest: "branch" },
+      "--resume-point": { dest: "resumePoint" },
+      "--status": { dest: "status" },
+      "--evidence": { dest: "evidence", append: true }
+    }
+  });
+
+  if (process.env.VCM_ROLE !== "project-manager") {
+    emit("warning", "Only project-manager may declare VCM task workflow state.");
+    return 0;
+  }
+
+  const apiUrl = (process.env.VCM_API_URL || "").replace(/\/+$/, "");
+  const taskSlug = (process.env.VCM_TASK_SLUG || "").trim();
+  if (!apiUrl || !taskSlug) {
+    emit("warning", "VCM_API_URL or VCM_TASK_SLUG is unavailable; task state was not updated.");
+    return 0;
+  }
+
+  const payload = {};
+  for (const key of ["flow", "step", "branch", "resumePoint", "status"]) {
+    if (args[key] !== undefined) {
+      payload[key] = args[key];
+    }
+  }
+  if (args.evidence.length > 0) {
+    payload.evidenceRefs = args.evidence;
+  }
+
+  if (Object.keys(payload).length === 0) {
+    emit("warning", "No task workflow fields were supplied.");
+    return 0;
+  }
+
+  const url = apiUrl + "/api/tasks/" + encodeURIComponent(taskSlug) + "/workflow-state";
+  try {
+    const response = await postJson(url, payload, 3000);
+    if (!response.ok) {
+      emit("warning", "Task state was not updated: HTTP Error " + response.status + ": " + response.statusText);
+      return 0;
+    }
+    emit("updated", undefined, JSON.parse(response.text));
+  } catch (error) {
+    emit("warning", "Task state was not updated: " + networkErrorText(error));
+  }
+  return 0;
+}
 
-if __name__ == "__main__":
-    sys.exit(main())
+main().then((code) => process.exit(code));
 `;
 }

package/dist/shared/types/app-settings.js

@@ -1,4 +1,35 @@
 import { VCM_ROLE_NAMES } from "../constants.js";
+export const ARCHITECT_WORKER_TYPES = ["evidence", "scaffold", "validation"];
+// "inherit" runs the worker on the parent Architect Session's model.
+export const ARCHITECT_WORKER_MODELS = ["inherit", "fable", "opus", "sonnet"];
+// "default" omits effort from the worker definition.
+export const ARCHITECT_WORKER_EFFORTS = ["default", "low", "medium", "high", "xhigh", "max"];
+// Workers run cheaper than the Architect that delegates to them: evidence reading
+// still needs judgment, while scaffold and validation execution are mechanical.
+export const DEFAULT_ARCHITECT_WORKER_SETTINGS = {
+    evidence: { model: "opus", effort: "high" },
+    scaffold: { model: "sonnet", effort: "medium" },
+    validation: { model: "sonnet", effort: "low" }
+};
+export function normalizeArchitectWorkerSettings(input) {
+    const candidate = input && typeof input === "object" ? input : {};
+    const normalized = {};
+    for (const type of ARCHITECT_WORKER_TYPES) {
+        const entry = candidate[type] && typeof candidate[type] === "object"
+            ? candidate[type]
+            : {};
+        const fallback = DEFAULT_ARCHITECT_WORKER_SETTINGS[type];
+        normalized[type] = {
+            model: ARCHITECT_WORKER_MODELS.includes(entry.model)
+                ? entry.model
+                : fallback.model,
+            effort: ARCHITECT_WORKER_EFFORTS.includes(entry.effort)
+                ? entry.effort
+                : fallback.effort
+        };
+    }
+    return normalized;
+}
 export const THEME_MODES = ["system", "light", "dark"];
 export const PERMISSION_REQUEST_MODES = ["off", "allowAll"];
 export const DEFAULT_TRANSLATION_TARGET_LANGUAGE = "zh-CN";