opencode-goal-mode 0.1.0

package/tests/agents.test.mjs

@@ -0,0 +1,70 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { filesIn, readRepo, frontmatter, hasLine } from "./helpers.mjs";
+
+const requiredAgents = [
+  "goal.md",
+  "goal-explorer.md",
+  "goal-researcher.md",
+  "goal-implementer.md",
+  "goal-reviewer.md",
+  "goal-prompt-auditor.md",
+  "goal-diff-reviewer.md",
+  "goal-verifier.md",
+  "goal-test-reviewer.md",
+  "goal-security-reviewer.md",
+  "goal-ux-reviewer.md",
+  "goal-ops-reviewer.md",
+  "goal-doc-reviewer.md",
+  "goal-final-auditor.md",
+  "goal-deep-researcher.md",
+  "goal-web-researcher.md",
+  "goal-architect.md",
+  "goal-mapper.md",
+  "goal-planner.md",
+  "goal-coordinator.md",
+  "goal-doc-writer.md",
+  "goal-commentator.md",
+  "goal-api-reviewer.md",
+  "goal-data-reviewer.md",
+  "goal-perf-reviewer.md",
+  "goal-quality-gate.md",
+  "goal-completion-guard.md",
+];
+
+test("all required agents exist", () => {
+  const files = filesIn("agents");
+  for (const agent of requiredAgents) assert.ok(files.includes(agent), `${agent} missing`);
+});
+
+test("agents have required frontmatter", () => {
+  for (const file of requiredAgents) {
+    const fm = frontmatter(readRepo(`agents/${file}`));
+    assert.ok(hasLine(fm, "description"), `${file} missing description`);
+    assert.ok(hasLine(fm, "mode"), `${file} missing mode`);
+    assert.ok(hasLine(fm, "permission"), `${file} missing permission`);
+  }
+});
+
+test("primary goal enforces review artifacts and final contract", () => {
+  const text = readRepo("agents/goal.md");
+  for (const phrase of [
+    "Goal Contract",
+    "Verification Ledger",
+    "Review Ledger",
+    "Required review matrix",
+    "Review handoff template",
+    "Goal Completed",
+    "Review cycles: N",
+  ]) {
+    assert.ok(text.includes(phrase), `goal.md missing ${phrase}`);
+  }
+});
+
+test("reviewers are read-only", () => {
+  for (const file of requiredAgents.filter((name) => name.includes("reviewer") || name.includes("auditor") || name.includes("verifier"))) {
+    const fm = frontmatter(readRepo(`agents/${file}`));
+    assert.match(fm, /edit:\s+deny/, `${file} must deny edit`);
+    assert.match(fm, /task:\s+deny/, `${file} must deny task nesting`);
+  }
+});

package/tests/commands.test.mjs

@@ -0,0 +1,23 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { filesIn, readRepo, frontmatter, hasLine } from "./helpers.mjs";
+
+const requiredCommands = ["goal.md", "goal-contract.md", "goal-review.md", "goal-status.md", "goal-repair.md", "goal-final.md"];
+
+test("all required commands exist", () => {
+  const files = filesIn("commands");
+  for (const command of requiredCommands) assert.ok(files.includes(command), `${command} missing`);
+});
+
+test("commands have descriptions and agent bindings", () => {
+  for (const file of requiredCommands) {
+    const fm = frontmatter(readRepo(`commands/${file}`));
+    assert.ok(hasLine(fm, "description"), `${file} missing description`);
+    assert.ok(hasLine(fm, "agent"), `${file} missing agent`);
+  }
+});
+
+test("review and final commands run as subtasks", () => {
+  assert.match(frontmatter(readRepo("commands/goal-review.md")), /subtask:\s+true/);
+  assert.match(frontmatter(readRepo("commands/goal-final.md")), /subtask:\s+true/);
+});

package/tests/helpers.mjs

@@ -0,0 +1,23 @@
+import { readFileSync, readdirSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+
+export const root = fileURLToPath(new URL("..", import.meta.url));
+
+export function filesIn(dir) {
+  return readdirSync(join(root, dir)).filter((file) => file.endsWith(".md") || file.endsWith(".js"));
+}
+
+export function readRepo(path) {
+  return readFileSync(join(root, path), "utf8");
+}
+
+export function frontmatter(text) {
+  const match = text.match(/^---\n([\s\S]*?)\n---\n/);
+  if (!match) throw new Error("Missing YAML frontmatter");
+  return match[1];
+}
+
+export function hasLine(fm, key) {
+  return new RegExp(`^${key}:`, "m").test(fm);
+}

package/tests/install.test.mjs

@@ -0,0 +1,64 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+import { readRepo } from "./helpers.mjs";
+
+const repoRoot = fileURLToPath(new URL("..", import.meta.url));
+
+test("installer copies only safe OpenCode component directories", () => {
+  const text = readRepo("scripts/install.mjs");
+  assert.match(text, /copyDirFiles\(join\(root, "agents"\)/);
+  assert.match(text, /copyDirFiles\(join\(root, "commands"\)/);
+  assert.match(text, /copyDirFiles\(join\(root, "plugins"\)/);
+  assert.doesNotMatch(text, /auth|sessions|preauth|failures|hosts\.yml/);
+});
+
+test("gitignore excludes secrets and dependencies", () => {
+  const text = readRepo(".gitignore");
+  for (const pattern of ["node_modules/", ".env", ".env.*"]) assert.ok(text.includes(pattern));
+});
+
+test("installer functionally copies components to project .opencode", () => {
+  const temp = mkdtempSync(join(tmpdir(), "goal-install-"));
+  execFileSync("node", [join(repoRoot, "scripts", "install.mjs")], { cwd: temp, stdio: "pipe" });
+  assert.equal(existsSync(join(temp, ".opencode", "agents", "goal.md")), true);
+  assert.equal(existsSync(join(temp, ".opencode", "commands", "goal.md")), true);
+  assert.equal(existsSync(join(temp, ".opencode", "plugins", "goal-guard.js")), true);
+});
+
+test("installer dry run does not write files", () => {
+  const temp = mkdtempSync(join(tmpdir(), "goal-install-dry-"));
+  execFileSync("node", [join(repoRoot, "scripts", "install.mjs"), "--dry-run"], { cwd: temp, stdio: "pipe" });
+  assert.equal(existsSync(join(temp, ".opencode")), false);
+});
+
+test("installer refuses to overwrite changed destination files", () => {
+  const temp = mkdtempSync(join(tmpdir(), "goal-install-conflict-"));
+  mkdirSync(join(temp, ".opencode", "agents"), { recursive: true });
+  writeFileSync(join(temp, ".opencode", "agents", "goal.md"), "local change\n");
+  assert.throws(
+    () => execFileSync("node", [join(repoRoot, "scripts", "install.mjs")], { cwd: temp, stdio: "pipe" }),
+    /Refusing to overwrite changed OpenCode component files/
+  );
+});
+
+test("installer force replaces changed destination files", () => {
+  const temp = mkdtempSync(join(tmpdir(), "goal-install-force-"));
+  mkdirSync(join(temp, ".opencode", "agents"), { recursive: true });
+  const dest = join(temp, ".opencode", "agents", "goal.md");
+  writeFileSync(dest, "local change\n");
+  execFileSync("node", [join(repoRoot, "scripts", "install.mjs"), "--force"], { cwd: temp, stdio: "pipe" });
+  assert.equal(readFileSync(dest, "utf8"), readFileSync(join(repoRoot, "agents", "goal.md"), "utf8"));
+});
+
+test("installer supports explicit target directory", () => {
+  const temp = mkdtempSync(join(tmpdir(), "goal-install-target-"));
+  const target = join(temp, "custom-opencode");
+  execFileSync("node", [join(repoRoot, "scripts", "install.mjs"), "--target", target], { cwd: temp, stdio: "pipe" });
+  assert.equal(existsSync(join(target, "agents", "goal.md")), true);
+  assert.equal(existsSync(join(target, "plugins", "goal-guard.js")), true);
+});

package/tests/plugin.test.mjs

@@ -0,0 +1,195 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import plugin, { __test } from "../plugins/goal-guard.js";
+
+test("detects destructive bash commands", () => {
+  assert.equal(__test.looksLikeDestructiveBash("rm -rf /tmp/x"), true);
+  assert.equal(__test.looksLikeDestructiveBash("sudo rm -fr /tmp/x"), true);
+  assert.equal(__test.looksLikeDestructiveBash("rm --recursive --force /tmp/x"), true);
+  assert.equal(__test.looksLikeDestructiveBash("git reset --hard"), true);
+  assert.equal(__test.looksLikeDestructiveBash("git push --force"), true);
+  assert.equal(__test.looksLikeDestructiveBash("find . -delete"), true);
+  assert.equal(__test.looksLikeDestructiveBash("find . -exec rm -f {} +"), true);
+  assert.equal(__test.looksLikeDestructiveBash("dd if=/tmp/x of=/dev/sda"), true);
+  assert.equal(__test.looksLikeDestructiveBash("npm test"), false);
+  assert.equal(__test.looksLikeDestructiveBash("ls -la"), false);
+});
+
+test("distinguishes read-only and mutating bash commands", () => {
+  assert.equal(__test.looksLikeMutatingBash("cat README.md"), false);
+  assert.equal(__test.looksLikeMutatingBash("rg goal agents"), false);
+  assert.equal(__test.looksLikeMutatingBash("node -e \"console.log('ok')\""), false);
+  assert.equal(__test.looksLikeMutatingBash("cat README.md > /tmp/goal-output.txt"), true);
+  assert.equal(__test.looksLikeMutatingBash("npm install"), true);
+  assert.equal(__test.looksLikeMutatingBash("npx prettier --write README.md"), true);
+});
+
+test("detects verification commands without generic test false positives", () => {
+  assert.equal(__test.isVerification("npm test"), true);
+  assert.equal(__test.isVerification("npm run validate"), true);
+  assert.equal(__test.isVerification("rg test README.md"), false);
+  assert.equal(__test.isVerification("node tests/plugin.test.mjs"), false);
+});
+
+test("state cache evicts at the configured session limit", () => {
+  __test.sessions.clear();
+  for (let i = 0; i < 205; i += 1) __test.stateFor(`session-${i}`);
+  assert.equal(__test.sessions.size, 200);
+});
+
+test("plugin blocks destructive bash before tool execution", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  await assert.rejects(
+    () => hooks["tool.execute.before"]({ tool: "bash", sessionID: "s", callID: "c" }, { args: { command: "git clean -fd" } }),
+    /blocked/i,
+  );
+});
+
+test("write tool marks session dirty", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  await hooks["tool.execute.after"]({ tool: "edit", sessionID: "dirty-test", callID: "c", args: {} }, { output: "", title: "", metadata: {} });
+  const state = __test.stateFor("dirty-test");
+  assert.equal(state.dirty, true);
+  assert.equal(Boolean(state.lastEditAt), true);
+});
+
+test("read-only bash does not mark session dirty", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "read-only-bash-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "c", args: { command: "cat README.md" } }, { output: "", title: "", metadata: {} });
+  const state = __test.stateFor(sessionID);
+  assert.equal(state.dirty, false);
+  assert.equal(state.lastEditAt, null);
+});
+
+test("mutating bash marks session dirty", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "mutating-bash-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "c", args: { command: "cat README.md > /tmp/goal-output.txt" } }, { output: "", title: "", metadata: {} });
+  const state = __test.stateFor(sessionID);
+  assert.equal(state.dirty, true);
+  assert.equal(Boolean(state.lastEditAt), true);
+});
+
+test("task tool captures review verdict from subagent", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "task-review-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "task", sessionID, callID: "c", args: { subagent_type: "goal-reviewer", prompt: "Review this." } }, { output: "Verdict: PASS", title: "", metadata: {} });
+  const state = __test.stateFor(sessionID);
+  assert.equal(state.verdicts.some((v) => v.agent === "goal-reviewer" && v.verdict === "PASS"), true);
+});
+
+test("task tool captures review failure from subagent", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "task-review-fail-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "task", sessionID, callID: "c", args: { subagent_type: "goal-final-auditor", prompt: "Audit this." } }, { output: "Verdict: FAIL", title: "", metadata: {} });
+  const state = __test.stateFor(sessionID);
+  assert.equal(state.verdicts.some((v) => v.agent === "goal-final-auditor" && v.verdict === "FAIL"), true);
+});
+
+test("verification command updates lastVerificationAt", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "verify-time-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  const before = new Date().toISOString();
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "c", args: { command: "npm test" } }, { output: "", title: "", metadata: {} });
+  const state = __test.stateFor(sessionID);
+  assert.equal(state.verificationSeen, true);
+  assert.ok(state.lastVerificationAt >= before);
+});
+
+test("task-based final auditor records one review cycle", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "task-final-cycle-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "task", sessionID, callID: "c", args: { subagent_type: "goal-final-auditor", prompt: "Audit this." } }, { output: "Verdict: PASS", title: "", metadata: {} });
+  const state = __test.stateFor(sessionID);
+  assert.equal(state.reviewCycles, 1);
+});
+
+test("final completion blocks claimed review cycles that do not match recorded", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "cycles-block-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "edit", sessionID, callID: "c", args: {} }, { output: "", title: "", metadata: {} });
+  // separate verification so review timestamps stay after it
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "v", args: { command: "npm test" } }, { output: "", title: "", metadata: {} });
+
+  for (const agent of ["goal-prompt-auditor", "goal-reviewer", "goal-diff-reviewer", "goal-verifier", "goal-final-auditor"]) {
+    await hooks["chat.params"]({ sessionID, agent }, {});
+    await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: agent, args: { command: "npm test" } }, { output: "Verdict: PASS", title: "", metadata: {} });
+  }
+
+  const output = { text: "Goal Completed\n\nReview cycles: 2" };
+  await hooks["experimental.text.complete"]({ sessionID, messageID: "m", partID: "p" }, output);
+  assert.match(output.text, /Goal Not Completed/);
+  assert.match(output.text, /do not match recorded/i);
+});
+
+test("final completion blocks missing review cycles entirely", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "zero-cycles-block-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "edit", sessionID, callID: "c", args: {} }, { output: "", title: "", metadata: {} });
+  await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: "v", args: { command: "npm test" } }, { output: "", title: "", metadata: {} });
+  const output = { text: "Goal Completed\n\nReview cycles: 0" };
+  await hooks["experimental.text.complete"]({ sessionID, messageID: "m", partID: "p" }, output);
+  assert.match(output.text, /Goal Not Completed/);
+  assert.match(output.text, /no review cycles recorded/i);
+});
+
+test("final completion blocks missing review cycles line", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  await hooks["chat.params"]({ sessionID: "missing-cycle-line-test", agent: "goal" }, {});
+  const output = { text: "Goal Completed\n\nDone." };
+  await hooks["experimental.text.complete"]({ sessionID: "missing-cycle-line-test", messageID: "m", partID: "p" }, output);
+  assert.match(output.text, /Goal Not Completed/);
+  assert.match(output.text, /missing required Review cycles line/i);
+});
+
+test("final completion is rewritten when dirty", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  await hooks["tool.execute.after"]({ tool: "edit", sessionID: "complete-test", callID: "c", args: {} }, { output: "", title: "", metadata: {} });
+  const output = { text: "Goal Completed\n\nReview cycles: 1" };
+  await hooks["experimental.text.complete"]({ sessionID: "complete-test", messageID: "m", partID: "p" }, output);
+  assert.match(output.text, /Goal Not Completed/);
+  assert.match(output.text, /blocked completion/i);
+});
+
+test("final completion is rewritten when required reviews never ran", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  await hooks["chat.params"]({ sessionID: "no-review-test", agent: "goal" }, {});
+  const output = { text: "Goal Completed\n\nReview cycles: 0" };
+  await hooks["experimental.text.complete"]({ sessionID: "no-review-test", messageID: "m", partID: "p" }, output);
+  assert.match(output.text, /Goal Not Completed/);
+  assert.match(output.text, /no review cycles recorded/i);
+});
+
+test("completion is allowed only after all required gates pass after edit", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const sessionID = "gate-pass-test";
+  await hooks["chat.params"]({ sessionID, agent: "goal" }, {});
+  await hooks["tool.execute.after"]({ tool: "edit", sessionID, callID: "c", args: {} }, { output: "", title: "", metadata: {} });
+
+  for (const agent of ["goal-prompt-auditor", "goal-reviewer", "goal-diff-reviewer", "goal-verifier", "goal-final-auditor"]) {
+    await hooks["chat.params"]({ sessionID, agent }, {});
+    await hooks["tool.execute.after"]({ tool: "bash", sessionID, callID: agent, args: { command: "npm test" } }, { output: "Verdict: PASS", title: "", metadata: {} });
+  }
+
+  const output = { text: "Goal Completed\n\nReview cycles: 1" };
+  await hooks["experimental.text.complete"]({ sessionID, messageID: "m", partID: "p" }, output);
+  assert.match(output.text, /Goal Completed/);
+  assert.doesNotMatch(output.text, /Goal Not Completed/);
+});
+
+test("compaction preserves goal guard state", async () => {
+  const hooks = await plugin({ client: { app: { log: async () => undefined } } });
+  const output = { context: [] };
+  await hooks["experimental.session.compacting"]({ sessionID: "compact-test" }, output);
+  assert.match(output.context.join("\n"), /Goal Guard state/);
+  assert.match(output.context.join("\n"), /Review Ledger/);
+});