tmux-ide 1.2.1 → 2.0.0

package/src/validate.test.ts

@@ -0,0 +1,385 @@
+import { describe, it, expect } from "bun:test";
+import { validateConfig } from "./validate.ts";
+
+describe("validateConfig", () => {
+  it("accepts a valid minimal config", () => {
+    const errors = validateConfig({ rows: [{ panes: [{}] }] });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts a valid full config", () => {
+    const errors = validateConfig({
+      name: "my-project",
+      before: "pnpm install",
+      rows: [
+        {
+          size: "70%",
+          panes: [
+            {
+              title: "Editor",
+              command: "vim",
+              dir: "src",
+              size: "60%",
+              focus: true,
+              env: { PORT: 3000, HOST: "localhost" },
+            },
+            { title: "Shell" },
+          ],
+        },
+        {
+          panes: [{ title: "Dev", command: "pnpm dev" }],
+        },
+      ],
+      theme: { accent: "colour75", border: "colour238", bg: "colour235", fg: "colour248" },
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("rejects null config", () => {
+    const errors = validateConfig(null);
+    expect(errors).toEqual(["config must be an object"]);
+  });
+
+  it("rejects string config", () => {
+    const errors = validateConfig("hello");
+    expect(errors).toEqual(["config must be an object"]);
+  });
+
+  it("rejects array config", () => {
+    const errors = validateConfig([]);
+    expect(errors).toEqual(["config must be an object"]);
+  });
+
+  it("requires rows to be an array", () => {
+    const errors = validateConfig({ rows: "nope" });
+    expect(errors.includes("'rows' must be an array")).toBeTruthy();
+  });
+
+  it("requires rows to be non-empty", () => {
+    const errors = validateConfig({ rows: [] });
+    expect(errors.includes("'rows' must not be empty")).toBeTruthy();
+  });
+
+  it("requires rows to have a panes array", () => {
+    const errors = validateConfig({ rows: [{}] });
+    expect(errors.includes("rows[0].panes must be an array")).toBeTruthy();
+  });
+
+  it("requires panes to be non-empty", () => {
+    const errors = validateConfig({ rows: [{ panes: [] }] });
+    expect(errors.includes("rows[0].panes must not be empty")).toBeTruthy();
+  });
+
+  it("rejects non-string name", () => {
+    const errors = validateConfig({ name: 123, rows: [{ panes: [{}] }] });
+    expect(errors.includes("'name' must be a string")).toBeTruthy();
+  });
+
+  it("rejects non-string before", () => {
+    const errors = validateConfig({ before: true, rows: [{ panes: [{}] }] });
+    expect(errors.includes("'before' must be a string")).toBeTruthy();
+  });
+
+  it("rejects non-string pane.title", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ title: 42 }] }] });
+    expect(errors.includes("rows[0].panes[0].title must be a string")).toBeTruthy();
+  });
+
+  it("rejects non-string pane.command", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ command: false }] }] });
+    expect(errors.includes("rows[0].panes[0].command must be a string")).toBeTruthy();
+  });
+
+  it("rejects non-string pane.dir", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ dir: [] }] }] });
+    expect(errors.includes("rows[0].panes[0].dir must be a string")).toBeTruthy();
+  });
+
+  it("rejects non-boolean pane.focus", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ focus: "yes" }] }] });
+    expect(errors.includes("rows[0].panes[0].focus must be a boolean")).toBeTruthy();
+  });
+
+  it("rejects non-object pane.env", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ env: "PORT=3000" }] }] });
+    expect(errors.includes("rows[0].panes[0].env must be an object")).toBeTruthy();
+  });
+
+  it("rejects invalid env values", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ env: { PORT: true } }] }] });
+    expect(errors.includes("rows[0].panes[0].env.PORT must be a string or number")).toBeTruthy();
+  });
+
+  it("rejects size without % suffix", () => {
+    const errors = validateConfig({ rows: [{ size: "70", panes: [{}] }] });
+    expect(errors.some((e) => e.includes("must be a percentage"))).toBeTruthy();
+  });
+
+  it("rejects 0% size", () => {
+    const errors = validateConfig({ rows: [{ size: "0%", panes: [{}] }] });
+    expect(errors.some((e) => e.includes("must be a percentage"))).toBeTruthy();
+  });
+
+  it("rejects >100% size", () => {
+    const errors = validateConfig({ rows: [{ panes: [{ size: "150%" }] }] });
+    expect(errors.some((e) => e.includes("must not exceed 100%"))).toBeTruthy();
+  });
+
+  it("validates theme fields as strings", () => {
+    const errors = validateConfig({ rows: [{ panes: [{}] }], theme: { accent: 123 } });
+    expect(errors.includes("theme.accent must be a string")).toBeTruthy();
+  });
+
+  it("accepts team metadata without requiring a lead pane", () => {
+    const errors = validateConfig({
+      team: { name: "my-team" },
+      rows: [
+        {
+          panes: [{ title: "Claude", command: "claude" }, { title: "Shell" }],
+        },
+      ],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("validates team pane role and task field types when provided", () => {
+    const errors = validateConfig({
+      team: { name: "my-team" },
+      rows: [
+        {
+          panes: [
+            { command: "claude", role: "manager", task: false },
+            { command: "claude", role: "teammate", task: "Review changes" },
+          ],
+        },
+      ],
+    });
+    expect(
+      errors.includes('rows[0].panes[0].role must be "lead", "teammate", or "planner"'),
+    ).toBeTruthy();
+    expect(errors.includes("rows[0].panes[0].task must be a string")).toBeTruthy();
+  });
+
+  it("rejects non-object theme", () => {
+    const errors = validateConfig({ rows: [{ panes: [{}] }], theme: "blue" });
+    expect(errors.includes("'theme' must be an object")).toBeTruthy();
+  });
+
+  it("rejects leading zeros in size (00%, 007%)", () => {
+    const errors = validateConfig({ rows: [{ size: "007%", panes: [{ size: "00%" }] }] });
+    expect(
+      errors.some((e) => e.includes('rows[0].size "007%"') && e.includes("percentage")),
+    ).toBeTruthy();
+    expect(
+      errors.some((e) => e.includes('rows[0].panes[0].size "00%"') && e.includes("percentage")),
+    ).toBeTruthy();
+  });
+
+  it("rejects row sizes summing over 100%", () => {
+    const errors = validateConfig({
+      rows: [
+        { size: "70%", panes: [{}] },
+        { size: "40%", panes: [{}] },
+      ],
+    });
+    expect(errors.some((e) => e.includes("Row sizes sum to 110%"))).toBeTruthy();
+  });
+
+  it("accepts row sizes summing to exactly 100%", () => {
+    const errors = validateConfig({
+      rows: [
+        { size: "70%", panes: [{}] },
+        { size: "30%", panes: [{}] },
+      ],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("rejects multiple focus: true in one row", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ focus: true }, { focus: true }] }],
+    });
+    expect(errors.some((e) => e.includes("Row 0 has 2 panes with focus: true"))).toBeTruthy();
+  });
+
+  it("accepts single focus: true per row", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ focus: true }, {}] }, { panes: [{}, { focus: true }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("rejects pane sizes summing over 100% in a row", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ size: "60%" }, { size: "50%" }] }],
+    });
+    expect(errors.some((e) => e.includes("Row 0 pane sizes sum to 110%"))).toBeTruthy();
+  });
+
+  it("accepts pane sizes summing to exactly 100%", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ size: "60%" }, { size: "40%" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts type: explorer pane", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "explorer", title: "Files" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts type: changes pane", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "changes", title: "Changes" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts type: preview pane", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "preview", title: "Preview" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts type: tasks pane", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "tasks", title: "Tasks" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts type: mission-control pane", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "mission-control", title: "Mission Control" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts type: costs pane", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "costs", title: "Costs" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("rejects invalid type value", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "invalid" }] }],
+    });
+    expect(errors.some((e) => e.includes("rows[0].panes[0].type must be one of:"))).toBeTruthy();
+  });
+
+  it("rejects type and command together", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "explorer", command: "vim" }] }],
+    });
+    expect(errors.includes("rows[0].panes[0] cannot have both 'type' and 'command'")).toBeTruthy();
+  });
+
+  it("rejects non-string target", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ target: 42 }] }],
+    });
+    expect(errors.includes("rows[0].panes[0].target must be a string")).toBeTruthy();
+  });
+
+  it("accepts string target", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{ type: "explorer", target: "Claude" }] }],
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts valid orchestrator config", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{}] }],
+      orchestrator: {
+        enabled: true,
+        auto_dispatch: true,
+        stall_timeout: 300000,
+        poll_interval: 5000,
+        master_pane: "Master",
+      },
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts config without orchestrator", () => {
+    const errors = validateConfig({ rows: [{ panes: [{}] }] });
+    expect(errors).toEqual([]);
+  });
+
+  it("rejects non-object orchestrator", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{}] }],
+      orchestrator: "enabled",
+    });
+    expect(errors.includes("'orchestrator' must be an object")).toBeTruthy();
+  });
+
+  it("rejects orchestrator with wrong field types", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{}] }],
+      orchestrator: {
+        enabled: "yes",
+        auto_dispatch: 1,
+        stall_timeout: "5000",
+        poll_interval: true,
+        master_pane: false,
+      },
+    });
+    expect(errors.includes("orchestrator.enabled must be a boolean")).toBeTruthy();
+    expect(errors.includes("orchestrator.auto_dispatch must be a boolean")).toBeTruthy();
+    expect(errors.includes("orchestrator.stall_timeout must be a number (ms)")).toBeTruthy();
+    expect(errors.includes("orchestrator.poll_interval must be a number (ms)")).toBeTruthy();
+    expect(errors.includes("orchestrator.master_pane must be a string")).toBeTruthy();
+  });
+
+  it("accepts orchestrator with only some fields", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{}] }],
+      orchestrator: { enabled: true },
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("accepts valid orchestrator hook and concurrency fields", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{}] }],
+      orchestrator: {
+        before_run: "pnpm install",
+        after_run: "pnpm test",
+        max_concurrent_agents: 3,
+        dispatch_mode: "goals",
+      },
+    });
+    expect(errors).toEqual([]);
+  });
+
+  it("rejects orchestrator hook and concurrency fields with wrong types", () => {
+    const errors = validateConfig({
+      rows: [{ panes: [{}] }],
+      orchestrator: {
+        before_run: 123,
+        after_run: false,
+        max_concurrent_agents: "ten",
+      },
+    });
+    expect(errors.includes("orchestrator.before_run must be a string")).toBeTruthy();
+    expect(errors.includes("orchestrator.after_run must be a string")).toBeTruthy();
+    expect(errors.includes("orchestrator.max_concurrent_agents must be a number")).toBeTruthy();
+  });
+
+  it("collects multiple errors at once", () => {
+    const errors = validateConfig({
+      name: 123,
+      before: [],
+      rows: [{ panes: [{ title: 42, focus: "yes", size: "0%" }] }],
+      theme: "nope",
+    });
+    expect(errors.length >= 4).toBeTruthy();
+  });
+});

package/src/validate.ts

@@ -0,0 +1,217 @@
+import { resolve } from "node:path";
+import { readConfig } from "./lib/yaml-io.ts";
+import { outputError } from "./lib/output.ts";
+import { IdeConfigSchema } from "./schemas/ide-config.ts";
+
+/** Minimal shape of Zod parse issues (v3/v4 compatible for our mappers). */
+interface ZodLikeIssue {
+  path?: (string | number)[];
+  code?: string;
+  message?: string;
+  expected?: string;
+  received?: string;
+}
+
+export function validateConfig(config: unknown): string[] {
+  if (config == null || typeof config !== "object" || Array.isArray(config)) {
+    return ["config must be an object"];
+  }
+
+  const result = IdeConfigSchema.safeParse(config);
+
+  if (!result.success) {
+    return result.error.issues.map((issue) => mapZodIssue(issue as ZodLikeIssue, config));
+  }
+
+  // Phase 2: semantic checks (only when schema parse succeeds)
+  const errors: string[] = [];
+  const cfg = result.data;
+
+  // 1. Row sizes sum ≤ 100%
+  const rowSizes = cfg.rows.filter((r) => r.size !== undefined).map((r) => parseInt(r.size!, 10));
+  const rowSum = rowSizes.reduce((a, b) => a + b, 0);
+  if (rowSum > 100) {
+    errors.push(`Row sizes sum to ${rowSum}%, which exceeds 100%`);
+  }
+
+  for (let i = 0; i < cfg.rows.length; i++) {
+    const row = cfg.rows[i]!;
+
+    // 2. Per-row pane sizes sum ≤ 100%
+    const paneSizes = row.panes
+      .filter((p) => p.size !== undefined)
+      .map((p) => parseInt(p.size!, 10));
+    const paneSum = paneSizes.reduce((a, b) => a + b, 0);
+    if (paneSum > 100) {
+      errors.push(`Row ${i} pane sizes sum to ${paneSum}%, which exceeds 100%`);
+    }
+
+    // 3. Max 1 focus:true per row
+    const focusCount = row.panes.filter((p) => p.focus === true).length;
+    if (focusCount > 1) {
+      errors.push(`Row ${i} has ${focusCount} panes with focus: true (max 1)`);
+    }
+
+    // 4. type and command cannot coexist
+    for (let j = 0; j < row.panes.length; j++) {
+      const pane = row.panes[j]!;
+      if (pane.type !== undefined && pane.command !== undefined) {
+        errors.push(`rows[${i}].panes[${j}] cannot have both 'type' and 'command'`);
+      }
+    }
+  }
+
+  return errors;
+}
+
+// ---------------------------------------------------------------------------
+// Zod issue → legacy error string mapping
+// ---------------------------------------------------------------------------
+
+function formatPath(path: (string | number)[]): string {
+  let result = "";
+  for (let i = 0; i < path.length; i++) {
+    const seg = path[i]!;
+    if (typeof seg === "number") {
+      result += `[${seg}]`;
+    } else if (i === 0) {
+      result += seg;
+    } else {
+      result += `.${seg}`;
+    }
+  }
+  return result;
+}
+
+function shouldQuote(path: (string | number)[]): boolean {
+  if (path.length === 1 && typeof path[0] === "string") return true;
+  if (path[0] === "team") return true;
+  return false;
+}
+
+function isSizePath(path: (string | number)[]): boolean {
+  return path[path.length - 1] === "size";
+}
+
+function isEnvValuePath(path: (string | number)[]): boolean {
+  const envIdx = path.indexOf("env");
+  return envIdx >= 0 && envIdx < path.length - 1;
+}
+
+function getValueAtPath(obj: unknown, path: (string | number)[]): unknown {
+  let current: unknown = obj;
+  for (const seg of path) {
+    if (current == null || typeof current !== "object") return undefined;
+    current = (current as Record<string, unknown>)[String(seg)];
+  }
+  return current;
+}
+
+const MS_FIELDS = new Set(["stall_timeout", "poll_interval"]);
+
+function typeDesc(path: (string | number)[], expected: string): string {
+  const base = expected.replace(/\s*\|\s*undefined/g, "").trim();
+  let desc: string;
+  if (base === "string") desc = "a string";
+  else if (base === "boolean") desc = "a boolean";
+  else if (base === "number") desc = "a number";
+  else if (base === "array") desc = "an array";
+  else if (base === "object" || base === "record") desc = "an object";
+  else desc = base;
+
+  const field = path[path.length - 1];
+  if (path[0] === "orchestrator" && typeof field === "string" && MS_FIELDS.has(field)) {
+    return `${desc} (ms)`;
+  }
+  return desc;
+}
+
+function mapZodIssue(issue: ZodLikeIssue, config: unknown): string {
+  const path: (string | number)[] = issue.path ?? [];
+  const code: string = issue.code ?? "";
+  const rawPath = formatPath(path);
+  const display = shouldQuote(path) ? `'${rawPath}'` : rawPath;
+  const lastSeg = path[path.length - 1];
+
+  // Env value: rows[i].panes[j].env.KEY
+  if (isEnvValuePath(path)) {
+    return `${formatPath(path)} must be a string or number`;
+  }
+
+  // Size field: regex or refine failure (but not a type error like size: 42)
+  if (isSizePath(path) && code !== "invalid_type") {
+    if (code === "custom") {
+      return `${rawPath} must not exceed 100%`;
+    }
+    const val = getValueAtPath(config, path);
+    return `${rawPath} "${val}" must be a percentage (e.g. "50%")`;
+  }
+
+  // Empty array (too_small from .min(1))
+  if (code === "too_small") {
+    return `${display} must not be empty`;
+  }
+
+  // Enum: pane type
+  if (code === "invalid_value" && lastSeg === "type" && path.includes("panes")) {
+    return `${rawPath} must be one of: explorer, changes, preview, tasks, costs, config, mission-control`;
+  }
+
+  // Enum: pane role
+  if (code === "invalid_value" && lastSeg === "role") {
+    return `${rawPath} must be "lead", "teammate", or "planner"`;
+  }
+
+  // Enum: dispatch_mode
+  if (code === "invalid_value" && lastSeg === "dispatch_mode") {
+    return `${rawPath} must be "tasks" or "goals"`;
+  }
+
+  // Team.name missing vs wrong type
+  if (path.length === 2 && path[0] === "team" && path[1] === "name") {
+    if (issue.received === "undefined") {
+      return "'team.name' is required when team is specified";
+    }
+  }
+
+  // Type mismatch
+  if (code === "invalid_type") {
+    return `${display} must be ${typeDesc(path, issue.expected ?? "")}`;
+  }
+
+  // Fallback
+  return `${display}: ${issue.message ?? "invalid value"}`;
+}
+
+export async function validate(
+  targetDir: string | undefined,
+  { json }: { json?: boolean } = {},
+): Promise<void> {
+  const dir = resolve(targetDir ?? ".");
+  let config;
+
+  try {
+    ({ config } = readConfig(dir));
+  } catch (e) {
+    outputError(`Cannot read ide.yml: ${(e as Error).message}`, "READ_ERROR");
+    return;
+  }
+
+  const errors = validateConfig(config);
+  const valid = errors.length === 0;
+
+  if (json) {
+    console.log(JSON.stringify({ valid, errors }, null, 2));
+    return;
+  }
+
+  if (valid) {
+    console.log("✓ ide.yml is valid");
+  } else {
+    console.log("✗ ide.yml has errors:");
+    for (const e of errors) {
+      console.log(`  - ${e}`);
+    }
+    process.exitCode = 1;
+  }
+}