pi-gsd 2.0.1 → 2.0.2

package/src/wxp/__tests__/schema.test.ts

@@ -1,120 +0,0 @@
-import { describe, it, expect } from "vitest";
-import {
-  ArgSchema,
-  OutSchema,
-  ShellNodeSchema,
-  StringOpNodeSchema,
-  ArgumentsNodeSchema,
-  PasteNodeSchema,
-  VersionTagSchema,
-  IncludeNodeSchema,
-  WxpVariableSchema,
-  WxpSecurityConfigSchema,
-} from "../../schemas/wxp.zod.js";
-
-describe("ArgSchema", () => {
-  it("parses a literal arg", () => {
-    const arg = ArgSchema.parse({ string: "execute-phase" });
-    expect(arg.string).toBe("execute-phase");
-  });
-
-  it("parses a variable-ref arg", () => {
-    const arg = ArgSchema.parse({ name: "phase", wrap: '"' });
-    expect(arg.name).toBe("phase");
-    expect(arg.wrap).toBe('"');
-  });
-
-  it("parses a typed literal arg", () => {
-    const arg = ArgSchema.parse({ type: "string", value: "@file:" });
-    expect(arg.type).toBe("string");
-    expect(arg.value).toBe("@file:");
-  });
-
-  it("parses a gsd-arguments flag arg", () => {
-    const arg = ArgSchema.parse({ name: "auto", type: "flag", flag: "--auto", optional: true });
-    expect(arg.type).toBe("flag");
-    expect(arg.flag).toBe("--auto");
-    expect(arg.optional).toBe(true);
-  });
-
-  it("rejects invalid type value", () => {
-    expect(() => ArgSchema.parse({ name: "x", type: "invalid" })).toThrow();
-  });
-});
-
-describe("OutSchema", () => {
-  it("parses a valid out element", () => {
-    const out = OutSchema.parse({ type: "string", name: "init" });
-    expect(out.type).toBe("string");
-    expect(out.name).toBe("init");
-  });
-
-  it("requires type and name", () => {
-    expect(() => OutSchema.parse({ name: "x" })).toThrow();
-    expect(() => OutSchema.parse({ type: "string" })).toThrow();
-  });
-});
-
-describe("ShellNodeSchema", () => {
-  it("parses a shell node with args and outs", () => {
-    const node = ShellNodeSchema.parse({
-      type: "shell",
-      command: "pi-gsd-tools",
-      args: [{ string: "init" }, { string: "execute-phase" }, { name: "phase", wrap: '"' }],
-      outs: [{ type: "string", name: "init" }],
-      suppressErrors: false,
-    });
-    expect(node.command).toBe("pi-gsd-tools");
-    expect(node.args).toHaveLength(3);
-    expect(node.outs).toHaveLength(1);
-  });
-
-  it("defaults args and outs to empty arrays", () => {
-    const node = ShellNodeSchema.parse({ type: "shell", command: "git" });
-    expect(node.args).toEqual([]);
-    expect(node.outs).toEqual([]);
-    expect(node.suppressErrors).toBe(false);
-  });
-});
-
-describe("StringOpNodeSchema", () => {
-  it("parses a split string-op", () => {
-    const node = StringOpNodeSchema.parse({
-      type: "string-op",
-      op: "split",
-      args: [{ name: "init" }, { type: "string", value: "@file:" }],
-      outs: [{ type: "string", name: "init-file" }],
-    });
-    expect(node.op).toBe("split");
-  });
-});
-
-describe("ArgumentsNodeSchema", () => {
-  it("parses a full gsd-arguments block", () => {
-    const node = ArgumentsNodeSchema.parse({
-      type: "arguments",
-      settings: { keepExtraArgs: false, strictArgs: false, delimiters: [] },
-      args: [
-        { name: "phase", type: "number" },
-        { name: "auto", type: "flag", flag: "--auto", optional: true },
-        { name: "user-text", type: "string", optional: true },
-      ],
-    });
-    expect(node.args).toHaveLength(3);
-    expect(node.args[1].type).toBe("flag");
-  });
-});
-
-describe("WxpSecurityConfigSchema", () => {
-  it("parses with structured trustedPaths", () => {
-    const cfg = WxpSecurityConfigSchema.parse({
-      trustedPaths: [
-        { position: "pkg", path: ".gsd/harnesses/pi/get-shit-done" },
-        { position: "project", path: ".pi/gsd" },
-      ],
-      shellAllowlist: ["pi-gsd-tools", "git"],
-    });
-    expect(cfg.trustedPaths).toHaveLength(2);
-    expect(cfg.shellTimeoutMs).toBe(30_000);
-  });
-});

package/src/wxp/__tests__/security.test.ts

@@ -1,87 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { checkTrustedPath, checkAllowlist, DEFAULT_SHELL_ALLOWLIST } from "../security.js";
-import type { WxpSecurityConfig } from "../../schemas/wxp.zod.js";
-
-const PROJECT_ROOT = "/project";
-const PKG_ROOT = "/pkg";
-
-const cfg: WxpSecurityConfig = {
-  trustedPaths: [
-    { position: "pkg", path: ".gsd/harnesses/pi/get-shit-done" },
-    { position: "project", path: ".pi/gsd" },
-  ],
-  untrustedPaths: [],
-  shellAllowlist: [...DEFAULT_SHELL_ALLOWLIST],
-  shellBanlist: [],
-  shellTimeoutMs: 30_000,
-};
-
-describe("checkTrustedPath", () => {
-  it("returns ok=true for file inside pkg harness", () => {
-    const result = checkTrustedPath(
-      "/pkg/.gsd/harnesses/pi/get-shit-done/workflows/execute-phase.md",
-      cfg, PROJECT_ROOT, PKG_ROOT,
-    );
-    expect(result.ok).toBe(true);
-  });
-
-  it("returns ok=true for file inside project harness", () => {
-    const result = checkTrustedPath(
-      "/project/.pi/gsd/workflows/plan-phase.md",
-      cfg, PROJECT_ROOT, PKG_ROOT,
-    );
-    expect(result.ok).toBe(true);
-  });
-
-  it("returns ok=false for file outside trusted paths", () => {
-    const result = checkTrustedPath("/untrusted/file.md", cfg, PROJECT_ROOT, PKG_ROOT);
-    expect(result.ok).toBe(false);
-  });
-
-  it("hard blocks .planning/ regardless of trusted paths", () => {
-    const cfgWithPlanning: WxpSecurityConfig = {
-      ...cfg,
-      trustedPaths: [{ position: "absolute", path: "/project" }],
-    };
-    const result = checkTrustedPath(
-      "/project/.planning/STATE.md",
-      cfgWithPlanning, PROJECT_ROOT, PKG_ROOT,
-    );
-    expect(result.ok).toBe(false);
-    if (!result.ok) expect(result.reason).toContain(".planning/");
-  });
-
-  it("untrustedPaths override trustedPaths", () => {
-    const cfgWithUntrusted: WxpSecurityConfig = {
-      ...cfg,
-      untrustedPaths: [{ position: "project", path: ".pi/gsd/dangerous" }],
-    };
-    const result = checkTrustedPath(
-      "/project/.pi/gsd/dangerous/file.md",
-      cfgWithUntrusted, PROJECT_ROOT, PKG_ROOT,
-    );
-    expect(result.ok).toBe(false);
-  });
-});
-
-describe("checkAllowlist", () => {
-  it("returns ok=true for all default allowlist entries", () => {
-    for (const cmd of DEFAULT_SHELL_ALLOWLIST) {
-      expect(checkAllowlist(cmd, cfg).ok).toBe(true);
-    }
-  });
-
-  it("returns ok=false for bash", () => {
-    expect(checkAllowlist("bash", cfg).ok).toBe(false);
-  });
-
-  it("strips path prefix before checking", () => {
-    expect(checkAllowlist("/usr/bin/git", cfg).ok).toBe(true);
-    expect(checkAllowlist("/usr/bin/bash", cfg).ok).toBe(false);
-  });
-
-  it("banlist overrides allowlist", () => {
-    const cfgWithBan: WxpSecurityConfig = { ...cfg, shellBanlist: ["git"] };
-    expect(checkAllowlist("git", cfgWithBan).ok).toBe(false);
-  });
-});

package/src/wxp/__tests__/shell.test.ts

@@ -1,85 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { Mock } from "vitest";
-
-vi.mock("node:child_process", () => ({
-  execFileSync: vi.fn().mockReturnValue("mocked-output\n"),
-}));
-
-import { executeShell, WxpShellError } from "../shell.js";
-import { createVariableStore } from "../variables.js";
-import type { WxpSecurityConfig, XmlNode } from "../../schemas/wxp.zod.js";
-import { execFileSync } from "node:child_process";
-import { x } from "./helpers.js";
-
-const cfg: WxpSecurityConfig = {
-  trustedPaths: [],
-  untrustedPaths: [],
-  shellAllowlist: ["pi-gsd-tools", "git", "node", "cat", "ls", "echo", "find"],
-  shellBanlist: [],
-  shellTimeoutMs: 30_000,
-};
-
-function shellNode(command: string, args: XmlNode[], outs: XmlNode[], suppress = false) {
-  return x("shell", { command }, [
-    x("args", {}, args),
-    x("outs", {}, suppress ? [...outs, x("suppress-errors")] : outs),
-  ]);
-}
-
-describe("executeShell", () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    (execFileSync as Mock).mockReturnValue("mocked-output\n");
-  });
-
-  it("executes allowlisted command and stores stdout in out variable", () => {
-    const vars = createVariableStore();
-    executeShell(
-      shellNode("pi-gsd-tools",
-        [x("arg", { string: "state" }), x("arg", { string: "json" })],
-        [x("out", { type: "string", name: "state" })]),
-      vars, cfg,
-    );
-    expect(vars.get("state")).toBe("mocked-output");
-  });
-
-  it("throws WxpShellError for non-allowlisted command (no process spawned)", () => {
-    const vars = createVariableStore();
-    expect(() => executeShell(
-      shellNode("bash", [], []),
-      vars, cfg,
-    )).toThrow(WxpShellError);
-    expect(execFileSync).not.toHaveBeenCalled();
-  });
-
-  it("resolves variable args with wrap", () => {
-    const vars = createVariableStore();
-    vars.set("phase", "16");
-    executeShell(
-      shellNode("pi-gsd-tools",
-        [x("arg", { string: "init" }), x("arg", { string: "execute-phase" }), x("arg", { name: "phase", wrap: '"' })],
-        [x("out", { type: "string", name: "init" })]),
-      vars, cfg,
-    );
-    expect(execFileSync).toHaveBeenCalledWith(
-      "pi-gsd-tools",
-      ["init", "execute-phase", '"16"'],
-      expect.objectContaining({ timeout: 30_000 }),
-    );
-  });
-
-  it("suppress-errors: stores empty string on failure instead of throwing", () => {
-    (execFileSync as Mock).mockImplementationOnce(() => {
-      throw Object.assign(new Error("exit 1"), { stderr: "error" });
-    });
-    const vars = createVariableStore();
-    expect(() => executeShell(
-      shellNode("pi-gsd-tools",
-        [x("arg", { string: "agent-skills" })],
-        [x("out", { type: "string", name: "skills" })],
-        true),
-      vars, cfg,
-    )).not.toThrow();
-    expect(vars.get("skills")).toBe("");
-  });
-});

package/src/wxp/__tests__/string-ops.test.ts

@@ -1,25 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { executeStringOp, WxpStringOpError } from "../string-ops.js";
-import { createVariableStore } from "../variables.js";
-import { x } from "./helpers.js";
-
-function splitNode(srcName: string, delimiter: string, outName: string) {
-  return x("string-op", { op: "split" }, [
-    x("args", {}, [x("arg", { name: srcName }), x("arg", { type: "string", value: delimiter })]),
-    x("outs", {}, [x("out", { type: "string", name: outName })]),
-  ]);
-}
-
-describe("executeStringOp split", () => {
-  it("splits @file: prefix and stores remainder", () => {
-    const vars = createVariableStore();
-    vars.set("init", "@file:/tmp/gsd-init.json");
-    executeStringOp(splitNode("init", "@file:", "init-file"), vars);
-    expect(vars.get("init-file")).toBe("/tmp/gsd-init.json");
-  });
-
-  it("throws WxpStringOpError when source variable is undefined", () => {
-    const vars = createVariableStore();
-    expect(() => executeStringOp(splitNode("missing", "@file:", "out"), vars)).toThrow(WxpStringOpError);
-  });
-});

package/src/wxp/__tests__/variables.test.ts

@@ -1,65 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { createVariableStore } from "../variables.js";
-
-describe("VariableStore", () => {
-  it("sets and gets a variable", () => {
-    const store = createVariableStore();
-    store.set("x", "hello");
-    expect(store.get("x")).toBe("hello");
-  });
-
-  it("returns undefined for missing variable", () => {
-    const store = createVariableStore();
-    expect(store.get("missing")).toBeUndefined();
-  });
-
-  it("has() returns true for existing variable", () => {
-    const store = createVariableStore();
-    store.set("a", "1");
-    expect(store.has("a")).toBe(true);
-    expect(store.has("b")).toBe(false);
-  });
-
-  it("snapshot() returns all key-value pairs", () => {
-    const store = createVariableStore();
-    store.set("a", "1", "file1");
-    store.set("b", "2", "file2");
-    const snap = store.snapshot();
-    expect(snap["a"]).toBe("1");
-    expect(snap["b"]).toBe("2");
-  });
-
-  it("collision detection: same name from different owners gets prefixed", () => {
-    const store = createVariableStore();
-    store.set("result", "first", "execute-phase");
-    store.set("result", "second", "plan-phase");
-    // Original "result" key should be gone; prefixed keys should exist
-    expect(store.get("result")).toBeUndefined();
-    expect(store.get("execute-phase:result")).toBe("first");
-    expect(store.get("plan-phase:result")).toBe("second");
-  });
-
-  it("no collision when owner is the same", () => {
-    const store = createVariableStore();
-    store.set("x", "v1", "file");
-    store.set("x", "v2", "file");
-    // Same owner: overwrite, no prefix
-    expect(store.get("x")).toBe("v2");
-  });
-
-  it("no collision when no owner provided", () => {
-    const store = createVariableStore();
-    store.set("x", "v1");
-    store.set("x", "v2");
-    expect(store.get("x")).toBe("v2");
-  });
-
-  it("entries() iterates over all stored variables", () => {
-    const store = createVariableStore();
-    store.set("a", "1");
-    store.set("b", "2");
-    const keys = [...store.entries()].map(([k]) => k);
-    expect(keys).toContain("a");
-    expect(keys).toContain("b");
-  });
-});

package/src/wxp/arguments.ts

@@ -1,89 +0,0 @@
-import type { XmlNode } from "../schemas/wxp.zod.js";
-import type { VariableStore } from "./variables.js";
-
-export class WxpArgumentsError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = "WxpArgumentsError";
-  }
-}
-
-export function parseArguments(node: XmlNode, rawArguments: string, vars: VariableStore): void {
-  const settingsNode = node.children.find((c) => c.tag === "settings");
-  const keepExtraArgs = settingsNode?.children.some((c) => c.tag === "keep-extra-args") ?? false;
-  const strictArgs    = settingsNode?.children.some((c) => c.tag === "strict-args")     ?? false;
-
-  const delimContainer = settingsNode?.children.find((c) => c.tag === "delimiters");
-  const firstDelim = delimContainer?.children.find((c) => c.tag === "delimiter");
-
-  let tokens: string[];
-  if (firstDelim) {
-    const raw = firstDelim.attrs["value"] ?? "";
-    const sep = raw === "\\n" ? "\n" : raw;
-    tokens = rawArguments.split(sep).map((t) => t.trim()).filter(Boolean);
-  } else {
-    tokens = rawArguments.trim().split(/\s+/).filter(Boolean);
-  }
-
-  const argDefs = node.children.filter((c) => c.tag === "arg");
-  const consumed = new Set<number>();
-
-  // ── Pass 1: flags ──────────────────────────────────────────────────────────
-  for (const def of argDefs.filter((a) => a.attrs["type"] === "flag")) {
-    const flagToken = def.attrs["flag"] ?? `--${def.attrs["name"]}`;
-    const idx = tokens.indexOf(flagToken);
-    const name = def.attrs["name"];
-    if (!name) continue;
-    if (idx === -1) {
-      vars.set(name, "false", undefined);
-    } else {
-      vars.set(name, "true", undefined);
-      consumed.add(idx);
-    }
-  }
-
-  // ── Pass 2: positionals ────────────────────────────────────────────────────
-  const positionals = argDefs.filter((a) => a.attrs["type"] !== "flag");
-  const remaining   = tokens.filter((_, i) => !consumed.has(i));
-  let tokenIdx = 0;
-
-  for (let i = 0; i < positionals.length; i++) {
-    const def    = positionals[i];
-    const name   = def.attrs["name"];
-    const type   = def.attrs["type"] ?? "string";
-    const isLast = i === positionals.length - 1;
-    if (!name) continue;
-
-    if (tokenIdx >= remaining.length) {
-      if (!("optional" in def.attrs)) {
-        throw new WxpArgumentsError(`Missing required argument '${name}' (type: ${type})`);
-      }
-      vars.set(name, "", undefined);
-      continue;
-    }
-
-    if (type === "string" && isLast) {
-      vars.set(name, remaining.slice(tokenIdx).join(" "), undefined);
-      tokenIdx = remaining.length;
-    } else if (type === "number") {
-      const raw = remaining[tokenIdx++];
-      const num = Number(raw);
-      if (isNaN(num)) throw new WxpArgumentsError(`Argument '${name}' expected a number, got '${raw}'`);
-      vars.set(name, String(num), undefined);
-    } else if (type === "boolean") {
-      const raw = remaining[tokenIdx++].toLowerCase();
-      if (raw !== "true" && raw !== "false") {
-        throw new WxpArgumentsError(`Argument '${name}' expected true/false, got '${raw}'`);
-      }
-      vars.set(name, raw, undefined);
-    } else {
-      vars.set(name, remaining[tokenIdx++] ?? "", undefined);
-    }
-  }
-
-  const extra = remaining.slice(tokenIdx).join(" ");
-  if (extra) {
-    if (strictArgs)    throw new WxpArgumentsError(`Unexpected extra arguments: '${extra}'`);
-    if (keepExtraArgs) vars.set("_extra", extra, undefined);
-  }
-}

package/src/wxp/conditions.ts

@@ -1,78 +0,0 @@
-import type { XmlNode } from "../schemas/wxp.zod.js";
-import type { VariableStore } from "./variables.js";
-
-const BINARY_OPS = new Set([
-  "equals", "not-equals", "starts-with", "contains",
-  "less-than", "greater-than", "less-than-or-equal", "greater-than-or-equal",
-]);
-
-export const CONDITION_OPS = new Set([...BINARY_OPS, "and", "or"]);
-
-function resolveOperand(node: XmlNode, vars: VariableStore): string {
-  if (node.attrs["name"]) return vars.resolve(node.attrs["name"]) ?? "";
-  if (node.attrs["value"] !== undefined) return node.attrs["value"];
-  return "";
-}
-
-function isNumeric(node: XmlNode): boolean {
-  return node.attrs["type"] === "number";
-}
-
-function evalBinary(node: XmlNode, vars: VariableStore): boolean {
-  const leftNode  = node.children.find((c) => c.tag === "left");
-  const rightNode = node.children.find((c) => c.tag === "right");
-  if (!leftNode || !rightNode) return false;
-
-  const numeric = isNumeric(leftNode) || isNumeric(rightNode);
-  if (numeric) {
-    const l = Number(resolveOperand(leftNode, vars));
-    const r = Number(resolveOperand(rightNode, vars));
-    switch (node.tag) {
-      case "equals":                return l === r;
-      case "not-equals":            return l !== r;
-      case "less-than":             return l < r;
-      case "greater-than":          return l > r;
-      case "less-than-or-equal":    return l <= r;
-      case "greater-than-or-equal": return l >= r;
-      default:                      return false;
-    }
-  }
-
-  const l = resolveOperand(leftNode, vars);
-  const r = resolveOperand(rightNode, vars);
-  switch (node.tag) {
-    case "equals":                return l === r;
-    case "not-equals":            return l !== r;
-    case "starts-with":           return l.startsWith(r);
-    case "contains":              return l.includes(r);
-    case "less-than":             return Number(l) < Number(r);
-    case "greater-than":          return Number(l) > Number(r);
-    case "less-than-or-equal":    return Number(l) <= Number(r);
-    case "greater-than-or-equal": return Number(l) >= Number(r);
-    default:                      return false;
-  }
-}
-
-export function evaluateCondExprNode(node: XmlNode, vars: VariableStore): boolean {
-  if (node.tag === "and") {
-    return node.children.filter((c) => CONDITION_OPS.has(c.tag)).every((c) => evaluateCondExprNode(c, vars));
-  }
-  if (node.tag === "or") {
-    return node.children.filter((c) => CONDITION_OPS.has(c.tag)).some((c) => evaluateCondExprNode(c, vars));
-  }
-  return evalBinary(node, vars);
-}
-
-/** Evaluate the condition of an <if> node. */
-export function evaluateCondition(ifNode: XmlNode, vars: VariableStore): boolean {
-  const condContainer = ifNode.children.find((c) => c.tag === "condition");
-  if (!condContainer) return false;
-  const exprNode = condContainer.children.find((c) => CONDITION_OPS.has(c.tag));
-  return exprNode ? evaluateCondExprNode(exprNode, vars) : false;
-}
-
-/** Evaluate a <where> node's condition. */
-export function evaluateWhere(whereNode: XmlNode, vars: VariableStore): boolean {
-  const exprNode = whereNode.children.find((c) => CONDITION_OPS.has(c.tag));
-  return exprNode ? evaluateCondExprNode(exprNode, vars) : true;
-}