pi-gsd 2.0.1 → 2.0.3

package/src/schemas/wxp.zod.ts

@@ -1,318 +0,0 @@
-/**
- * src/schemas/wxp.zod.ts — Zod runtime schemas for the WXP engine.
- *
- * Single <arg> and <out> element types regardless of context.
- * All types inferred via z.infer<> — zero `any` except required z.lazy circular refs.
- */
-import { z } from "zod";
-
-// ─── <arg> ────────────────────────────────────────────────────────────────────
-
-export const ArgTypeSchema = z.enum(["string", "number", "boolean", "flag"]);
-export type ArgType = z.infer<typeof ArgTypeSchema>;
-
-export const OutTypeSchema = z.enum(["string"]);
-export type OutType = z.infer<typeof OutTypeSchema>;
-
-export const ArgSchema = z.object({
-  string: z.string().optional(),
-  name: z.string().optional(),
-  wrap: z.string().optional(),
-  type: ArgTypeSchema.optional(),
-  value: z.string().optional(),
-  flag: z.string().optional(),
-  optional: z.boolean().optional(),
-  as: z.string().optional(),
-});
-export type Arg = z.infer<typeof ArgSchema>;
-
-// ─── <out> ────────────────────────────────────────────────────────────────────
-
-export const OutSchema = z.object({
-  type: OutTypeSchema,
-  name: z.string(),
-});
-export type Out = z.infer<typeof OutSchema>;
-
-// ─── <delimiter> ─────────────────────────────────────────────────────────────
-
-export const DelimiterSchema = z.object({
-  type: z.literal("string"),
-  value: z.string(),
-});
-export type Delimiter = z.infer<typeof DelimiterSchema>;
-
-// ─── <settings> (inside <gsd-arguments>) ────────────────────────────────────
-
-export const ArgumentsSettingsSchema = z.object({
-  keepExtraArgs: z.boolean().default(false),
-  strictArgs: z.boolean().default(false),
-  delimiters: z.array(DelimiterSchema).default([]),
-});
-export type ArgumentsSettings = z.infer<typeof ArgumentsSettingsSchema>;
-
-// ─── <gsd-arguments> ─────────────────────────────────────────────────────────
-
-export const ArgumentsNodeSchema = z.object({
-  type: z.literal("arguments"),
-  settings: ArgumentsSettingsSchema.default({}),
-  args: z.array(ArgSchema).default([]),
-});
-export type ArgumentsNode = z.infer<typeof ArgumentsNodeSchema>;
-
-// ─── <shell> ─────────────────────────────────────────────────────────────────
-
-export const ShellNodeSchema = z.object({
-  type: z.literal("shell"),
-  command: z.string(),
-  args: z.array(ArgSchema).default([]),
-  outs: z.array(OutSchema).default([]),
-  suppressErrors: z.boolean().default(false),
-});
-export type ShellNode = z.infer<typeof ShellNodeSchema>;
-
-// ─── <string-op> ─────────────────────────────────────────────────────────────
-
-export const StringOpNodeSchema = z.object({
-  type: z.literal("string-op"),
-  op: z.literal("split"),
-  args: z.array(ArgSchema),
-  outs: z.array(OutSchema),
-});
-export type StringOpNode = z.infer<typeof StringOpNodeSchema>;
-
-// ─── <json-parse> ────────────────────────────────────────────────────────────
-// Parses a JSON string variable into a scalar string or an array of JSON strings.
-// path: optional dot-path like "$.phases" or "$.meta.name"
-
-export const JsonParseNodeSchema = z.object({
-  type: z.literal("json-parse"),
-  src: z.string(),
-  path: z.string().optional(),
-  out: z.string(),
-});
-export type JsonParseNode = z.infer<typeof JsonParseNodeSchema>;
-
-// ─── <read-file> ─────────────────────────────────────────────────────────────
-// Reads any accessible file into a named variable.
-// No trusted-path restriction — same surface as <shell command="cat"> already provides.
-
-export const ReadFileNodeSchema = z.object({
-  type: z.literal("read-file"),
-  path: z.string(),
-  out: z.string(),
-});
-export type ReadFileNode = z.infer<typeof ReadFileNodeSchema>;
-
-// ─── <write-file> ────────────────────────────────────────────────────────────
-// Create-only: fails if file already exists (never overwrites existing state).
-// Cannot target trusted harness paths (prevents harness corruption).
-// Creates parent directories as needed.
-
-export const WriteFileNodeSchema = z.object({
-  type: z.literal("write-file"),
-  path: z.string(),
-  src: z.string(),
-});
-export type WriteFileNode = z.infer<typeof WriteFileNodeSchema>;
-
-// ─── <display> ───────────────────────────────────────────────────────────────
-// Emits ctx.ui.notify(). msg supports {varname} and {var.prop} interpolation.
-
-export const DisplayLevelSchema = z.enum(["info", "warning", "error"]);
-export type DisplayLevel = z.infer<typeof DisplayLevelSchema>;
-
-export const DisplayNodeSchema = z.object({
-  type: z.literal("display"),
-  msg: z.string(),
-  level: DisplayLevelSchema.default("info"),
-});
-export type DisplayNode = z.infer<typeof DisplayNodeSchema>;
-
-// ─── Condition operands ───────────────────────────────────────────────────────
-// <left> and <right> use the same attribute set as <arg>
-
-export const OperandSchema = ArgSchema;
-export type Operand = z.infer<typeof OperandSchema>;
-
-// ─── Condition expressions ────────────────────────────────────────────────────
-// Binary ops: have <left> and <right> operands
-// Logical ops: <and>/<or> wrap arrays of ConditionExpr (recursive via z.lazy)
-
-export const BinaryCondOpSchema = z.enum([
-  "equals",
-  "not-equals",
-  "starts-with",
-  "contains",
-  "less-than",
-  "greater-than",
-  "less-than-or-equal",
-  "greater-than-or-equal",
-]);
-export type BinaryCondOp = z.infer<typeof BinaryCondOpSchema>;
-
-export interface BinaryCondExpr {
-  op: BinaryCondOp;
-  left: Operand;
-  right: Operand;
-}
-
-export interface AndCondExpr {
-  op: "and";
-  children: ConditionExpr[];
-}
-
-export interface OrCondExpr {
-  op: "or";
-  children: ConditionExpr[];
-}
-
-export type ConditionExpr = BinaryCondExpr | AndCondExpr | OrCondExpr;
-
-// Zod schemas (z.lazy for recursive and/or)
-const BinaryCondExprSchema = z.object({
-  op: BinaryCondOpSchema,
-  left: OperandSchema,
-  right: OperandSchema,
-});
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any -- required for z.lazy circular ref
-export const ConditionExprSchema: z.ZodType<any> = z.lazy(() =>
-  z.union([
-    BinaryCondExprSchema,
-    z.object({ op: z.literal("and"), children: z.array(ConditionExprSchema) }),
-    z.object({ op: z.literal("or"),  children: z.array(ConditionExprSchema) }),
-  ]),
-);
-
-// ─── <sort-by> (child of <for-each>) ─────────────────────────────────────────
-
-export const SortBySchema = z.object({
-  key: z.string(),
-  type: z.enum(["string", "number"]).default("string"),
-  order: z.enum(["asc", "desc"]).default("asc"),
-});
-export type SortBy = z.infer<typeof SortBySchema>;
-
-// ─── <if> (recursive) ────────────────────────────────────────────────────────
-
-export interface IfNode {
-  type: "if";
-  condition: ConditionExpr;
-  then: WxpOperation[];
-  else?: WxpOperation[];
-}
-
-// ─── <for-each> ──────────────────────────────────────────────────────────────
-
-export interface ForEachNode {
-  type: "for-each";
-  /** Name of the array variable to iterate */
-  var: string;
-  /** Name assigned to each item during iteration */
-  item: string;
-  /** Optional pre-filter: only items matching this condition are iterated */
-  where?: ConditionExpr;
-  /** Optional sort before iteration */
-  sortBy?: SortBy;
-  children: WxpOperation[];
-}
-
-// ─── <gsd-execute> ───────────────────────────────────────────────────────────
-
-export interface ExecuteBlock {
-  type: "execute";
-  children: WxpOperation[];
-}
-
-// ─── <gsd-paste> ─────────────────────────────────────────────────────────────
-
-export const PasteNodeSchema = z.object({
-  type: z.literal("paste"),
-  name: z.string(),
-});
-export type PasteNode = z.infer<typeof PasteNodeSchema>;
-
-// ─── <gsd-include> ───────────────────────────────────────────────────────────
-
-export const IncludeNodeSchema = z.object({
-  type: z.literal("include"),
-  path: z.string(),
-  select: z.string().optional(),
-  includeArguments: z.boolean().default(false),
-  argMappings: z.array(ArgSchema).default([]),
-});
-export type IncludeNode = z.infer<typeof IncludeNodeSchema>;
-
-// ─── <gsd-version> ───────────────────────────────────────────────────────────
-
-export const VersionTagSchema = z.object({
-  type: z.literal("version"),
-  v: z.string(),
-  doNotUpdate: z.boolean().default(false),
-});
-export type VersionTag = z.infer<typeof VersionTagSchema>;
-
-// ─── WxpOperation union ───────────────────────────────────────────────────────
-
-export type WxpOperation =
-  | ShellNode
-  | StringOpNode
-  | JsonParseNode
-  | ReadFileNode
-  | WriteFileNode
-  | DisplayNode
-  | IfNode
-  | ForEachNode
-  | ExecuteBlock
-  | PasteNode
-  | IncludeNode
-  | VersionTag
-  | ArgumentsNode;
-
-// ─── Variable store entry ─────────────────────────────────────────────────────
-
-export const WxpVariableSchema = z.object({
-  name: z.string(),
-  value: z.string(),
-  owner: z.string().optional(),
-});
-export type WxpVariable = z.infer<typeof WxpVariableSchema>;
-
-// ─── XML node (parser intermediate) ──────────────────────────────────────────
-
-export interface XmlNode {
-  tag: string;
-  attrs: Record<string, string>;
-  children: XmlNode[];
-  selfClosing: boolean;
-}
-
-// ─── Security config ──────────────────────────────────────────────────────────
-
-export const TrustedPathEntrySchema = z.object({
-  position: z.enum(["project", "pkg", "absolute"]),
-  path: z.string(),
-});
-
-export const WxpSecurityConfigSchema = z.object({
-  trustedPaths: z.array(TrustedPathEntrySchema),
-  untrustedPaths: z.array(TrustedPathEntrySchema).default([]),
-  shellAllowlist: z.array(z.string()),
-  shellBanlist: z.array(z.string()).default([]),
-  shellTimeoutMs: z.number().default(30_000),
-});
-
-export type TrustedPathEntry = z.infer<typeof TrustedPathEntrySchema>;
-export type WxpSecurityConfig = z.infer<typeof WxpSecurityConfigSchema>;
-
-// ─── Execution context (threads config + display callback through engine) ─────
-
-export type DisplayCallback = (msg: string, level: DisplayLevel) => void;
-
-export interface WxpExecContext {
-  config: WxpSecurityConfig;
-  projectRoot: string;
-  pkgRoot: string;
-  onDisplay: DisplayCallback;
-}

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

@@ -1,86 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { parseArguments, WxpArgumentsError } from "../arguments.js";
-import { createVariableStore } from "../variables.js";
-import { x } from "./helpers.js";
-
-// Build a <gsd-arguments> XmlNode from a declarative spec
-function argsNode(opts: {
-  keep?: boolean;
-  strict?: boolean;
-  args: Array<{ name: string; type: string; flag?: string; optional?: boolean }>;
-}) {
-  const settingsChildren = [];
-  if (opts.keep)   settingsChildren.push(x("keep-extra-args"));
-  if (opts.strict) settingsChildren.push(x("strict-args"));
-
-  const argNodes = opts.args.map((a) => {
-    const attrs: Record<string, string> = { name: a.name, type: a.type };
-    if (a.flag)     attrs["flag"]     = a.flag;
-    if (a.optional) attrs["optional"] = "";
-    return x("arg", attrs);
-  });
-
-  return x("gsd-arguments", {}, [
-    x("settings", {}, settingsChildren),
-    ...argNodes,
-  ]);
-}
-
-describe("parseArguments — two-pass (PRD §3.2)", () => {
-  it("extracts flag and assigns positional", () => {
-    const vars = createVariableStore();
-    parseArguments(argsNode({
-      args: [
-        { name: "phase", type: "number" },
-        { name: "auto-chain-active", type: "flag", flag: "--auto", optional: true },
-      ],
-    }), "1 --auto", vars);
-    expect(vars.get("phase")).toBe("1");
-    expect(vars.get("auto-chain-active")).toBe("true");
-  });
-
-  it("absent flag defaults to false", () => {
-    const vars = createVariableStore();
-    parseArguments(argsNode({
-      args: [{ name: "dry-run", type: "flag", flag: "--dry-run", optional: true }],
-    }), "", vars);
-    expect(vars.get("dry-run")).toBe("false");
-  });
-
-  it("greedy last string consumes all remaining tokens", () => {
-    const vars = createVariableStore();
-    parseArguments(argsNode({
-      args: [
-        { name: "phase", type: "number" },
-        { name: "auto", type: "flag", flag: "--auto", optional: true },
-        { name: "user-text", type: "string", optional: true },
-      ],
-    }), "1 --auto fix the login bug", vars);
-    expect(vars.get("phase")).toBe("1");
-    expect(vars.get("auto")).toBe("true");
-    expect(vars.get("user-text")).toBe("fix the login bug");
-  });
-
-  it("throws on missing required positional", () => {
-    const vars = createVariableStore();
-    expect(() => parseArguments(argsNode({
-      args: [{ name: "phase", type: "number" }],
-    }), "", vars)).toThrow(WxpArgumentsError);
-  });
-
-  it("number type: throws on NaN", () => {
-    const vars = createVariableStore();
-    expect(() => parseArguments(argsNode({
-      args: [{ name: "phase", type: "number" }],
-    }), "notanumber", vars)).toThrow(WxpArgumentsError);
-  });
-
-  it("keep-extra-args stores extra in _extra", () => {
-    const vars = createVariableStore();
-    parseArguments(argsNode({
-      keep: true,
-      args: [{ name: "phase", type: "number" }],
-    }), "1 extra stuff", vars);
-    expect(vars.get("_extra")).toBe("extra stuff");
-  });
-});

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

@@ -1,106 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { evaluateCondition, evaluateCondExprNode } from "../conditions.js";
-import { createVariableStore } from "../variables.js";
-import { x } from "./helpers.js";
-
-// Build an <if> node with a condition expression node inside <condition>
-function ifNode(condExpr: ReturnType<typeof x>) {
-  return x("if", {}, [x("condition", {}, [condExpr])]);
-}
-
-function eq(leftAttrs: Record<string, string>, rightAttrs: Record<string, string>) {
-  return x("equals", {}, [x("left", leftAttrs), x("right", rightAttrs)]);
-}
-
-function sw(leftAttrs: Record<string, string>, rightAttrs: Record<string, string>) {
-  return x("starts-with", {}, [x("left", leftAttrs), x("right", rightAttrs)]);
-}
-
-describe("evaluateCondition", () => {
-  it("equals: true when variable matches", () => {
-    const vars = createVariableStore();
-    vars.set("mode", "silent");
-    expect(evaluateCondition(
-      ifNode(eq({ name: "mode" }, { type: "string", value: "silent" })),
-      vars,
-    )).toBe(true);
-  });
-
-  it("equals: false when variable does not match", () => {
-    const vars = createVariableStore();
-    vars.set("mode", "interactive");
-    expect(evaluateCondition(
-      ifNode(eq({ name: "mode" }, { type: "string", value: "silent" })),
-      vars,
-    )).toBe(false);
-  });
-
-  it("starts-with: true when value starts with prefix", () => {
-    const vars = createVariableStore();
-    vars.set("init", "@file:/tmp/foo.json");
-    expect(evaluateCondition(
-      ifNode(sw({ name: "init" }, { type: "string", value: "@file:" })),
-      vars,
-    )).toBe(true);
-  });
-
-  it("equals with boolean literal", () => {
-    const vars = createVariableStore();
-    vars.set("auto-chain-active", "false");
-    expect(evaluateCondition(
-      ifNode(eq({ name: "auto-chain-active" }, { type: "boolean", value: "false" })),
-      vars,
-    )).toBe(true);
-  });
-
-  it("returns false (not throws) when variable is undefined", () => {
-    const vars = createVariableStore();
-    expect(evaluateCondition(
-      ifNode(eq({ name: "missing" }, { type: "string", value: "x" })),
-      vars,
-    )).toBe(false);
-  });
-});
-
-describe("evaluateCondExprNode — and/or", () => {
-  it("and: all children must be true", () => {
-    const vars = createVariableStore();
-    vars.set("a", "1"); vars.set("b", "2");
-    expect(evaluateCondExprNode(x("and", {}, [
-      eq({ name: "a" }, { value: "1" }),
-      eq({ name: "b" }, { value: "2" }),
-    ]), vars)).toBe(true);
-
-    expect(evaluateCondExprNode(x("and", {}, [
-      eq({ name: "a" }, { value: "1" }),
-      eq({ name: "b" }, { value: "99" }),
-    ]), vars)).toBe(false);
-  });
-
-  it("or: any child true is sufficient", () => {
-    const vars = createVariableStore();
-    vars.set("x", "hello");
-    expect(evaluateCondExprNode(x("or", {}, [
-      eq({ name: "x" }, { value: "nope" }),
-      eq({ name: "x" }, { value: "hello" }),
-    ]), vars)).toBe(true);
-  });
-
-  it("not-equals", () => {
-    const vars = createVariableStore();
-    vars.set("status", "complete");
-    expect(evaluateCondExprNode(
-      x("not-equals", {}, [x("left", { name: "status" }), x("right", { value: "pending" })]),
-      vars,
-    )).toBe(true);
-  });
-
-  it("less-than with numeric coercion", () => {
-    const vars = createVariableStore();
-    vars.set("n", "3");
-    expect(evaluateCondExprNode(
-      x("less-than", {}, [x("left", { name: "n", type: "number" }), x("right", { type: "number", value: "5" })]),
-      vars,
-    )).toBe(true);
-  });
-});

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

@@ -1,95 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
-import type { Mock } from "vitest";
-
-vi.mock("node:child_process", () => ({
-  execFileSync: vi.fn().mockReturnValue("exec-output\n"),
-}));
-
-import { executeBlock, WxpExecutionError } from "../executor.js";
-import { createVariableStore } from "../variables.js";
-import type { WxpExecContext } from "../../schemas/wxp.zod.js";
-import { x } from "./helpers.js";
-
-const makeCtx = (): WxpExecContext => ({
-  config: {
-    trustedPaths: [],
-    untrustedPaths: [],
-    shellAllowlist: ["git", "pi-gsd-tools", "node", "cat", "ls", "echo", "find"],
-    shellBanlist: [],
-    shellTimeoutMs: 30_000,
-  },
-  projectRoot: "/project",
-  pkgRoot: "/pkg",
-  onDisplay: () => {},
-});
-
-// Build a <gsd-execute> container
-function exec(...children: ReturnType<typeof x>[]) {
-  return x("gsd-execute", {}, children);
-}
-
-describe("executeBlock", () => {
-  beforeEach(() => vi.clearAllMocks());
-
-  it("executes a shell child and stores result", () => {
-    const vars = createVariableStore();
-    executeBlock(exec(
-      x("shell", { command: "git" }, [
-        x("args", {}, [x("arg", { string: "status" })]),
-        x("outs", {}, [x("out", { type: "string", name: "out" })]),
-      ]),
-    ), vars, makeCtx());
-    expect(vars.get("out")).toBe("exec-output");
-  });
-
-  it("evaluates if/condition/equals and executes then-branch when true", () => {
-    const vars = createVariableStore();
-    vars.set("auto-chain-active", "false");
-    executeBlock(exec(
-      x("if", {}, [
-        x("condition", {}, [
-          x("equals", {}, [
-            x("left", { name: "auto-chain-active" }),
-            x("right", { type: "boolean", value: "false" }),
-          ]),
-        ]),
-        x("then", {}, [
-          x("shell", { command: "git" }, [
-            x("args", {}, []),
-            x("outs", {}, [x("out", { type: "string", name: "branch" })]),
-          ]),
-        ]),
-      ]),
-    ), vars, makeCtx());
-    expect(vars.get("branch")).toBe("exec-output");
-  });
-
-  it("skips then-branch when condition is false", () => {
-    const vars = createVariableStore();
-    vars.set("auto-chain-active", "true");
-    executeBlock(exec(
-      x("if", {}, [
-        x("condition", {}, [
-          x("equals", {}, [
-            x("left", { name: "auto-chain-active" }),
-            x("right", { type: "boolean", value: "false" }),
-          ]),
-        ]),
-        x("then", {}, [
-          x("shell", { command: "git" }, [
-            x("args", {}, []),
-            x("outs", {}, [x("out", { type: "string", name: "branch" })]),
-          ]),
-        ]),
-      ]),
-    ), vars, makeCtx());
-    expect(vars.get("branch")).toBeUndefined();
-  });
-
-  it("wraps errors in WxpExecutionError", () => {
-    const vars = createVariableStore();
-    expect(() => executeBlock(exec(
-      x("shell", { command: "bash" }, [x("args", {}, []), x("outs", {}, [])]),
-    ), vars, makeCtx())).toThrow(WxpExecutionError);
-  });
-});

package/src/wxp/__tests__/helpers.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect } from "vitest";
-import type { XmlNode } from "../../schemas/wxp.zod.js";
-
-// ─── XmlNode builder helper ───────────────────────────────────────────────────
-export function x(
-  tag: string,
-  attrs: Record<string, string> = {},
-  children: XmlNode[] = [],
-): XmlNode {
-  return { tag, attrs, children, selfClosing: children.length === 0 && !attrs["__open"] };
-}
-
-describe("x() helper sanity", () => {
-  it("builds a self-closing node", () => {
-    const node = x("arg", { string: "hello" });
-    expect(node.tag).toBe("arg");
-    expect(node.attrs["string"]).toBe("hello");
-    expect(node.selfClosing).toBe(true);
-  });
-
-  it("builds a node with children", () => {
-    const node = x("args", {}, [x("arg", { string: "a" })]);
-    expect(node.children).toHaveLength(1);
-    expect(node.selfClosing).toBe(false);
-  });
-});