@runweave/server-linux-x64 0.1.7 → 0.1.9

package/payload/plugins/toolkit/skills/github-pr/scripts/source-worktree.mjs

@@ -0,0 +1,354 @@
+#!/usr/bin/env node
+import { spawnSync } from "node:child_process";
+import fs from "node:fs";
+import path from "node:path";
+import { createHash, randomUUID } from "node:crypto";
+
+// Capture before copying/staging. Receipts contain recovery data, never stdout.
+const env = { ...process.env };
+for (const key of [
+  "GIT_DIR",
+  "GIT_WORK_TREE",
+  "GIT_COMMON_DIR",
+  "GIT_INDEX_FILE",
+])
+  delete env[key];
+env.GIT_OPTIONAL_LOCKS = "0";
+function git(cwd, args, optional = false) {
+  const result = spawnSync("git", ["-C", cwd, ...args], {
+    env,
+    encoding: "utf8",
+    maxBuffer: 32 * 1024 * 1024,
+  });
+  if (result.error || result.status !== 0) {
+    if (optional && !result.error) return null;
+    throw new Error(result.error?.message ?? result.stderr.trim());
+  }
+  return result.stdout;
+}
+const digest = (bytes) => createHash("sha256").update(bytes).digest("hex");
+const split = (value) => value.split("\0").filter(Boolean);
+function tree(cwd, revision) {
+  return Object.fromEntries(
+    split(git(cwd, ["ls-tree", "-r", "-z", revision])).map((entry) => {
+      const tab = entry.indexOf("\t");
+      const [mode, , oid] = entry.slice(0, tab).split(" ");
+      return [entry.slice(tab + 1), { mode, oid }];
+    }),
+  );
+}
+function state(cwd) {
+  const head = git(cwd, ["rev-parse", "HEAD"]).trim();
+  const baseline = tree(cwd, head);
+  const indexPath = path.resolve(
+    cwd,
+    git(cwd, ["rev-parse", "--git-path", "index"]).trim(),
+  );
+  const index = fs.readFileSync(indexPath).toString("base64");
+  const entries = Object.fromEntries(
+    split(git(cwd, ["ls-files", "--stage", "-z"])).map((entry) => {
+      const tab = entry.indexOf("\t");
+      const [mode, oid, stage] = entry.slice(0, tab).split(" ");
+      if (stage !== "0")
+        throw new Error("Unmerged index; retain source worktree");
+      return [entry.slice(tab + 1), { mode, oid }];
+    }),
+  );
+  const names = new Set([
+    ...split(git(cwd, ["diff", "HEAD", "--name-only", "--no-renames", "-z"])),
+    ...split(
+      git(cwd, ["diff", "--cached", "--name-only", "--no-renames", "-z"]),
+    ),
+    ...split(git(cwd, ["ls-files", "--others", "--exclude-standard", "-z"])),
+  ]);
+  const fileMode =
+    git(cwd, ["config", "--get", "core.filemode"], true)?.trim() !== "false";
+  const files = {};
+  for (const name of [...names].sort()) {
+    const full = path.join(cwd, name);
+    let stat;
+    try {
+      stat = fs.lstatSync(full);
+    } catch (error) {
+      if (error.code !== "ENOENT") throw error;
+    }
+    if (!stat) {
+      files[name] = { working: null, index: entries[name] ?? null };
+      continue;
+    }
+    if (!stat.isFile() && !stat.isSymbolicLink())
+      throw new Error(`Unsupported path: ${name}`);
+    const bytes = stat.isSymbolicLink()
+      ? Buffer.from(fs.readlinkSync(full))
+      : fs.readFileSync(full);
+    const mode = stat.isSymbolicLink()
+      ? "120000"
+      : !fileMode && entries[name]
+        ? entries[name].mode
+        : stat.mode & 0o111
+          ? "100755"
+          : "100644";
+    const oid = stat.isSymbolicLink()
+      ? spawnSync("git", ["-C", cwd, "hash-object", "--stdin"], {
+          env,
+          input: bytes,
+          encoding: "utf8",
+        })
+      : { status: 0, stdout: git(cwd, ["hash-object", "--", name]) };
+    if (oid.status !== 0) throw new Error(`Cannot hash ${name}`);
+    files[name] = {
+      working: { mode, oid: oid.stdout.trim() },
+      index: entries[name] ?? null,
+      rawSHA256: digest(bytes),
+      data: bytes.toString("base64"),
+      permissions: stat.mode & 0o777,
+      tracked: Boolean(baseline[name]),
+    };
+  }
+  return { head, indexPath, index, files };
+}
+const equal = (left, right) =>
+  JSON.stringify(left ?? null) === JSON.stringify(right ?? null);
+function inspect(receipt, targetRef) {
+  const cwd = receipt.cwd;
+  if (
+    fs.realpathSync(
+      path.resolve(cwd, git(cwd, ["rev-parse", "--git-common-dir"]).trim()),
+    ) !== receipt.repository
+  ) {
+    throw new Error("Source repository identity changed");
+  }
+  const target = git(cwd, [
+    "rev-parse",
+    "--verify",
+    `${targetRef}^{commit}`,
+  ]).trim();
+  const current = state(cwd),
+    targetTree = tree(cwd, target);
+  const changed = [
+    ...new Set([
+      ...Object.keys(receipt.snapshot.files),
+      ...Object.keys(current.files),
+    ]),
+  ].filter((name) => !equal(receipt.snapshot.files[name], current.files[name]));
+  const covered = [],
+    retained = [];
+  for (const [name, file] of Object.entries(current.files)) {
+    if (
+      receipt.ownedPaths.includes(name) &&
+      equal(file.working, targetTree[name])
+    )
+      covered.push(name);
+    else retained.push(name);
+  }
+  const base = git(cwd, ["merge-base", current.head, target]).trim();
+  const sourceTree = tree(cwd, current.head);
+  const historyUncovered = split(
+    git(cwd, ["diff", "--name-only", "--no-renames", "-z", base, current.head]),
+  ).filter(
+    (name) =>
+      !equal(
+        covered.includes(name) ? current.files[name].working : sourceTree[name],
+        targetTree[name],
+      ),
+  );
+  // A staged version differing from the final working file is a separate payload.
+  const indexUncovered = covered.filter((name) => {
+    const file = current.files[name];
+    return (
+      !equal(file.index, sourceTree[name]) && !equal(file.index, file.working)
+    );
+  });
+  return {
+    target,
+    current,
+    covered,
+    retained,
+    changed,
+    historyUncovered,
+    indexUncovered,
+    canFinish:
+      current.head === receipt.snapshot.head &&
+      current.index === receipt.snapshot.index &&
+      changed.length === 0 &&
+      historyUncovered.length === 0 &&
+      indexUncovered.length === 0,
+  };
+}
+function restoreIndex(snapshot) {
+  const lock = `${snapshot.indexPath}.lock`;
+  fs.writeFileSync(lock, Buffer.from(snapshot.index, "base64"), {
+    flag: "wx",
+    mode: 0o600,
+  });
+  fs.renameSync(lock, snapshot.indexPath);
+}
+function finish(receipt, audit, receiptPath) {
+  if (!audit.canFinish)
+    throw new Error(
+      "Source changed or contains unpublished history/index content; inspect receipt and retain source",
+    );
+  const cwd = receipt.cwd,
+    snapshot = audit.current;
+  const backupRef = `refs/heads/backup/pr-source-${randomUUID()}`;
+  git(cwd, [
+    "update-ref",
+    backupRef,
+    snapshot.head,
+    "0".repeat(snapshot.head.length),
+  ]);
+  // Re-check before entering rollback: a changed source must never be restored.
+  if (!equal(state(cwd), snapshot))
+    throw new Error("Source changed before synchronization");
+  const removed = [];
+  let stagedIndex;
+  try {
+    for (const name of audit.covered) {
+      const file = snapshot.files[name];
+      if (!file.tracked && !file.index) {
+        fs.unlinkSync(path.join(cwd, name));
+        removed.push(name);
+      } else {
+        git(cwd, ["add", "--", name]);
+      }
+    }
+    stagedIndex = fs.readFileSync(snapshot.indexPath).toString("base64");
+    // No --force, reset, clean or stash: Git refuses overlapping residual edits.
+    git(cwd, ["checkout", "--detach", audit.target]);
+  } catch (error) {
+    if (git(cwd, ["rev-parse", "HEAD"]).trim() === snapshot.head) {
+      if (
+        stagedIndex &&
+        fs.readFileSync(snapshot.indexPath).toString("base64") !== stagedIndex
+      ) {
+        throw new Error(
+          `Index changed; retain recovery receipt ${receiptPath}: ${error.message}`,
+        );
+      }
+      restoreIndex(snapshot);
+      for (const name of removed) {
+        const file = snapshot.files[name],
+          full = path.join(cwd, name);
+        fs.mkdirSync(path.dirname(full), { recursive: true });
+        if (file.working.mode === "120000")
+          fs.symlinkSync(Buffer.from(file.data, "base64").toString(), full);
+        else
+          fs.writeFileSync(full, Buffer.from(file.data, "base64"), {
+            flag: "wx",
+            mode: file.permissions,
+          });
+      }
+    }
+    throw new Error(
+      `Synchronization incomplete; backup ${backupRef}, receipt ${receiptPath}: ${error.message}`,
+    );
+  }
+  const after = state(cwd);
+  const mismatches = audit.covered.filter((name) => after.files[name]);
+  for (const name of audit.retained) {
+    const before = snapshot.files[name],
+      next = after.files[name];
+    if (
+      !next ||
+      before.rawSHA256 !== next.rawSHA256 ||
+      !equal(before.working, next.working) ||
+      !equal(before.index, next.index)
+    )
+      mismatches.push(name);
+  }
+  if (after.head !== audit.target || mismatches.length) {
+    throw new Error(
+      `Post-sync verification failed; retain backup ${backupRef} and receipt ${receiptPath}: ${mismatches.join(", ")}`,
+    );
+  }
+  return {
+    synchronized: true,
+    target: audit.target,
+    covered: audit.covered,
+    retained: audit.retained,
+    backupRef,
+    receipt: receiptPath,
+  };
+}
+
+try {
+  const [command, first, second, third, ...rest] = process.argv.slice(2);
+  if (command === "capture" && first && second && third && rest.length === 0) {
+    const cwd = fs.realpathSync(
+      git(path.resolve(first), ["rev-parse", "--show-toplevel"]).trim(),
+    );
+    const receiptPath = path.resolve(second),
+      scopePath = path.resolve(third);
+    if (receiptPath === cwd || receiptPath.startsWith(`${cwd}${path.sep}`))
+      throw new Error("Keep recovery receipt outside source worktree");
+    const ownedPaths = JSON.parse(fs.readFileSync(scopePath, "utf8"));
+    if (
+      !Array.isArray(ownedPaths) ||
+      ownedPaths.some(
+        (name) =>
+          typeof name !== "string" ||
+          !name ||
+          path.isAbsolute(name) ||
+          name.split("/").includes(".."),
+      )
+    )
+      throw new Error(
+        "Scope must be a JSON array of repository-relative paths",
+      );
+    const repository = fs.realpathSync(
+      path.resolve(cwd, git(cwd, ["rev-parse", "--git-common-dir"]).trim()),
+    );
+    const snapshot = state(cwd);
+    if (!equal(snapshot, state(cwd)))
+      throw new Error("Source changed during capture");
+    fs.writeFileSync(
+      receiptPath,
+      JSON.stringify({ version: 1, cwd, repository, ownedPaths, snapshot }),
+      { flag: "wx", mode: 0o600 },
+    );
+    console.log(
+      JSON.stringify({
+        captured: true,
+        source: cwd,
+        head: snapshot.head,
+        receipt: receiptPath,
+      }),
+    );
+  } else if (
+    ["inspect", "finish"].includes(command) &&
+    first &&
+    second &&
+    rest.length === 0 &&
+    (command === "inspect" ? !third : third === "--source-idle")
+  ) {
+    const receiptPath = path.resolve(first),
+      receipt = JSON.parse(fs.readFileSync(receiptPath, "utf8"));
+    if (receipt.version !== 1) throw new Error("Unsupported receipt version");
+    const audit = inspect(receipt, second);
+    console.log(
+      JSON.stringify(
+        command === "finish"
+          ? finish(receipt, audit, receiptPath)
+          : {
+              source: receipt.cwd,
+              target: audit.target,
+              sourceHeadChanged: audit.current.head !== receipt.snapshot.head,
+              sourceIndexChanged:
+                audit.current.index !== receipt.snapshot.index,
+              covered: audit.covered,
+              retained: audit.retained,
+              changed: audit.changed,
+              historyUncovered: audit.historyUncovered,
+              indexUncovered: audit.indexUncovered,
+              canFinish: audit.canFinish,
+            },
+      ),
+    );
+  } else
+    throw new Error(
+      "Usage: source-worktree.mjs capture <source> <receipt.json> <scope.json> | inspect <receipt.json> <target> | finish <receipt.json> <target> --source-idle",
+    );
+} catch (error) {
+  console.error(JSON.stringify({ synchronized: false, error: error.message }));
+  process.exitCode = 1;
+}

package/payload/plugins/toolkit/skills/grill-with-docs/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: grill-with-docs
+description: Stress-test a feature or design through a repo-grounded interview while recording resolved domain language in CONTEXT.md and durable architectural decisions in ADRs. Use when a codebase needs both design alignment and a documentation trail; do not use for a discussion that should not modify project docs.
+metadata:
+  source: "https://github.com/mattpocock/skills/tree/main/skills/engineering/grill-with-docs"
+  adapted_for: "Runweave Toolkit"
+---
+
+# Grill with Docs
+
+Turn an unsettled feature or design into shared understanding and durable project knowledge. Combine a rigorous design interview with active domain modeling. Do not implement the design while this skill is active.
+
+## Ground the discussion
+
+Before asking a question:
+
+1. Read the repository instructions and any plan or draft the user identified.
+2. Locate the relevant `CONTEXT.md`. If the repository has `CONTEXT-MAP.md`, use it to select the bounded context; otherwise use the repository-level context.
+3. Read relevant ADRs and inspect the code paths that can establish current behavior.
+
+Finding facts is the agent's job. Answer questions from the repository or available tools instead of asking the user to rediscover facts.
+
+## Run the grill
+
+Map the design as a decision tree and resolve prerequisite decisions before dependent ones.
+
+- Ask one high-value decision question at a time and wait for the user's answer.
+- Give a recommended answer with the concrete reason and important trade-off.
+- Challenge vague, overloaded, or contradictory terms. Propose one canonical term when that will make the model clearer.
+- Use concrete scenarios and edge cases to test the boundaries between concepts.
+- When the user's description conflicts with existing docs or code, show the evidence and ask which behavior is authoritative.
+- Recompute the unresolved decision tree after every answer.
+
+Do not start implementation, write a specification, or create tickets until the user confirms that shared understanding has been reached.
+
+## Record resolved language
+
+Update the relevant `CONTEXT.md` as soon as a domain term is resolved. Preserve the file's existing structure and vocabulary.
+
+`CONTEXT.md` is a glossary:
+
+- Define domain concepts, distinctions, relationships, and invariants in the project's language.
+- Do not add implementation details, design alternatives, task lists, or specification content.
+- Create the file lazily only after the first stable term is resolved.
+
+If unrelated user changes already exist in the file, preserve them and edit only the resolved entry.
+
+## Record durable decisions
+
+Offer an ADR only when all three conditions are true:
+
+1. Reversing the decision later would have meaningful cost.
+2. A future reader would find the choice surprising without its context.
+3. The decision resolves a real trade-off between credible alternatives.
+
+If any condition is missing, do not create an ADR. Follow the repository's existing ADR convention; when none exists, use `docs/adr/` and continue its numeric sequence. Record the context, decision, alternatives, and consequences without turning the ADR into an implementation plan.
+
+## Finish
+
+The grill is complete only when every reachable decision branch is resolved and the user confirms shared understanding. Then report:
+
+- the agreed design boundaries;
+- the glossary entries and ADRs created or changed;
+- any explicitly deferred questions.
+
+If no term or decision met the documentation threshold, leave the repository unchanged and say so.

package/payload/plugins/toolkit/skills/grill-with-docs/agents/openai.yaml

@@ -0,0 +1,6 @@
+interface:
+  display_name: "Grill with Docs"
+  short_description: "Stress-test a design and preserve its decisions"
+  default_prompt: "Use $grill-with-docs to challenge this design and record the resulting domain terms and durable decisions."
+policy:
+  allow_implicit_invocation: false

package/payload/plugins/toolkit/skills/grilling/SKILL.md

@@ -0,0 +1,14 @@
+---
+name: grilling
+description: Grill the user relentlessly about a plan or design. Use when the user wants to stress-test a plan before building, or uses any 'grill' trigger phrases.
+---
+
+# Grilling
+
+Interview me relentlessly about every aspect of this plan until we reach a shared understanding. Walk down each branch of the design tree, resolving dependencies between decisions one-by-one. For each question, provide your recommended answer.
+
+Ask the questions one at a time, waiting for feedback on each question before continuing. Asking multiple questions at once is bewildering.
+
+If a question can be answered by exploring the codebase, explore the codebase instead.
+
+Do not enact the plan until I confirm we have reached a shared understanding.

package/payload/plugins/toolkit/skills/handoff/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: handoff
+description: 当用户明确要求“交接”“handoff”“把当前任务交给另一个 Agent”时使用；把当前任务写成自包含的 Markdown 交接文档，再让一个零对话上下文的新 Agent 在当前工作区按文档执行。不要用于普通任务拆分、并行调研或任务编排。
+---
+
+# Handoff
+
+把当前任务交给一个全新的执行 Agent。交接以磁盘上的 Markdown 文档为唯一任务合同，不复制当前对话，也不引入 Runweave 后端、专属 UI 或通知协议。
+
+## 边界
+
+- 仅在用户明确要求交接时触发。
+- 新 Agent 必须在当前工作区执行；Worktree 创建、跨 Workspace 放置和长期 Agent 管理不属于本 skill。
+- 新 Agent 从零对话上下文启动，只能依赖仓库文件和交接文档。
+- 当前 Agent 完成交接后不得继续修改目标文件，避免与执行 Agent 竞争。
+- 交接不扩大授权。只读、诊断、实现、提交、推送等语义必须与用户原始要求一致。
+
+## 写交接文档
+
+将文档写入 `.runweave/handoffs/<YYYYMMDD-HHmmss>-<task-slug>.md`。创建前读取当前任务涉及的代码、最近的 `AGENTS.md` 和必要的 Git 状态，不凭记忆补全事实。
+
+文档必须让不了解当前对话的人直接执行，按需包含：
+
+```markdown
+# Handoff: <任务标题>
+
+## Task
+
+用祈使句准确描述要完成的工作，并明确是调查、评审、修改还是交付。
+
+## User intent
+
+记录用户真正要解决的问题和已经明确的取舍，不擅自扩大目标。
+
+## Context
+
+说明任务为何存在，以及理解任务所需的最少背景。
+
+## Relevant files
+
+- `path/to/file`：职责和与任务的关系
+
+## Current state
+
+已经完成什么、什么仍未完成、当前已知行为是什么。
+
+## What was tried
+
+- 尝试及结果；没有则写“无”。
+
+## Decisions
+
+- 已确定的决定及原因。
+
+## Acceptance criteria
+
+- [ ] 可独立判断通过或失败的标准。
+
+## Constraints
+
+- 必须保留的行为、权限边界和明确非目标。
+
+## Workspace snapshot
+
+- Working directory
+- Git branch and HEAD
+- 与本任务相关的未提交改动；不得把无关用户改动归入任务范围
+
+## Verification
+
+应执行的检查及成功标准；未获授权的外部写操作不得写成默认步骤。
+```
+
+保留准确的文件路径、错误文本、命令结果和用户决策，但不要复制密钥、Token、Cookie、个人数据或无关的大段日志。调查任务必须明确写 `DO NOT edit files`；修改任务写清允许修改的范围；“提交”“推送”“创建 PR”等权限分别记录，不能相互推导。
+
+## 启动执行 Agent
+
+文档写完后，使用宿主提供的 sub-agent 能力启动一个新 Agent：
+
+- 使用零对话继承模式；在 Codex collaboration 中传 `fork_turns: "none"`。
+- 不指定模型覆盖，除非用户明确指定接收 Agent 或模型。
+- 给新 Agent 的启动消息只包含交接文档绝对路径和以下要求：先读取适用的 `AGENTS.md`，再把交接文档视为唯一任务合同，完成其中工作和验证，并在文档末尾追加 `## Execution result`，记录结果、验证和遗留问题。
+- 不把交接文档内容再次粘贴进启动消息。若不读文档也能执行，说明交接仍依赖了隐藏上下文。
+
+当前 Agent 等待新 Agent 完成，但不实现自己的轮询、状态机或通知协议。执行 Agent 需要用户新增授权或遇到无法从代码判断的产品决策时，将问题原样交还用户。
+
+如果宿主没有 sub-agent 能力，只完成交接文档并明确报告无法启动接收 Agent；不要由当前 Agent 冒充新的执行 Agent。
+
+## 完成
+
+收到执行结果后，当前 Agent 只做必要的事实核对并向用户报告：
+
+- 交接文档路径；
+- 执行 Agent 完成了什么；
+- 实际执行的验证及结果；
+- 未完成项或需要用户决定的事项。
+
+不要把子 Agent 的自述当作已验证事实；高风险或外部状态结果仍需相应证据。

package/payload/plugins/toolkit/skills/karpathy-guidelines/SKILL.md

@@ -0,0 +1,73 @@
+---
+name: karpathy-guidelines
+description: Behavioral guidelines to reduce common LLM coding mistakes. Use when writing, reviewing, or refactoring code to avoid overcomplication, make surgical changes, surface assumptions, and define verifiable success criteria.
+license: MIT
+---
+
+# Karpathy Guidelines
+
+Behavioral guidelines to reduce common LLM coding mistakes, derived from [Andrej Karpathy's observations](https://x.com/karpathy/status/2015883857489522876) on LLM coding pitfalls.
+
+Apply these guidelines within the user's requested scope and the repository's instructions, including its verification policy.
+
+## 1. Think Before Coding
+
+**Ground decisions in context. Surface consequential uncertainty.**
+
+Before implementing:
+
+- Resolve questions from the code and existing context first. Choose routine, reversible implementation details using established patterns; state assumptions that materially affect the result.
+- Ask when missing information could change the goal, scope, authorization, or acceptance criteria and cannot be resolved from context. Pause only the dependent work; continue useful work within the agreed scope.
+- If a simpler approach exists, say so. Push back when warranted.
+
+## 2. Simplicity First
+
+**Minimum code that solves the problem. Nothing speculative.**
+
+- No features beyond what was asked.
+- No abstractions for single-use code.
+- No "flexibility" or "configurability" that wasn't requested.
+- No error handling for impossible scenarios.
+- If you write 200 lines and it could be 50, rewrite it.
+
+Ask yourself: "Would a senior engineer say this is overcomplicated?" If yes, simplify.
+
+## 3. Surgical Changes
+
+**Touch only what you must. Clean up only your own mess.**
+
+When editing existing code:
+
+- Don't "improve" adjacent code, comments, or formatting.
+- Don't refactor things that aren't broken.
+- Match existing style, even if you'd do it differently.
+- If you notice unrelated dead code, mention it - don't delete it.
+
+When your changes create orphans:
+
+- Remove imports/variables/functions that YOUR changes made unused.
+- Don't remove pre-existing dead code unless asked.
+
+The test: Every changed line should trace directly to the user's request.
+
+## 4. Goal-Driven Execution
+
+**Define success criteria. Verify in proportion to the change.**
+
+Follow the repository's verification policy. Prefer existing checks and direct behavior verification; do not require new test files or TDD by default. Complete required checks, then expand verification only when a change, failure, or unresolved concern warrants it. Report any verification gaps explicitly.
+
+Transform tasks into verifiable goals:
+
+- "Add validation" → "Verify representative valid and invalid inputs behave as required"
+- "Fix the bug" → "Check the reported failure path and verify the corrected behavior"
+- "Refactor X" → "Verify affected behavior remains unchanged using relevant existing checks"
+
+For multi-step tasks, state a brief plan:
+
+```
+1. [Step] → verify: [check]
+2. [Step] → verify: [check]
+3. [Step] → verify: [check]
+```
+
+Strong success criteria let you loop independently. Weak criteria ("make it work") require constant clarification.