tmux-ide 1.2.1 → 2.0.0

package/src/schemas/domain.ts

@@ -0,0 +1,422 @@
+import { z } from "zod";
+
+// ---------------------------------------------------------------------------
+// ProofSchema (from src/types.ts)
+// ---------------------------------------------------------------------------
+
+export const ProofSchemaZ = z.object({
+  tests: z.object({ passed: z.number(), total: z.number() }).optional(),
+  pr: z
+    .object({
+      number: z.number(),
+      url: z.string().optional(),
+      status: z.string().optional(),
+    })
+    .optional(),
+  ci: z.object({ status: z.string(), url: z.string().optional() }).optional(),
+  notes: z.string().optional(),
+});
+
+export type ProofSchema = z.infer<typeof ProofSchemaZ>;
+
+// ---------------------------------------------------------------------------
+// Task / Goal / Mission (from src/lib/task-store.ts)
+// ---------------------------------------------------------------------------
+
+export const MilestoneSchemaZ = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  status: z.enum(["locked", "active", "done", "validating"]),
+  order: z.number(),
+  created: z.string(),
+  updated: z.string(),
+});
+
+export const MissionSchemaZ = z.object({
+  title: z.string(),
+  description: z.string(),
+  status: z.enum(["planning", "active", "validating", "complete"]),
+  branch: z.string().nullable(),
+  milestones: z.array(MilestoneSchemaZ),
+  created: z.string(),
+  updated: z.string(),
+});
+
+export const GoalSchemaZ = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  status: z.enum(["todo", "in-progress", "done"]),
+  acceptance: z.string(),
+  priority: z.number(),
+  created: z.string(),
+  updated: z.string(),
+  assignee: z.string().nullable(),
+  specialty: z.string().nullable(),
+  milestone: z.string().nullable(),
+});
+
+export const TaskSchemaZ = z.object({
+  id: z.string(),
+  title: z.string(),
+  description: z.string(),
+  goal: z.string().nullable(),
+  status: z.enum(["todo", "in-progress", "review", "done"]),
+  assignee: z.string().nullable(),
+  priority: z.number(),
+  created: z.string(),
+  updated: z.string(),
+  tags: z.array(z.string()),
+  proof: ProofSchemaZ.nullable(),
+  retryCount: z.number(),
+  maxRetries: z.number(),
+  lastError: z.string().nullable(),
+  nextRetryAt: z.string().nullable(),
+  depends_on: z.array(z.string()),
+  milestone: z.string().nullable(),
+  specialty: z.string().nullable(),
+  fulfills: z.array(z.string()),
+  discoveredIssues: z.array(z.string()),
+  salientSummary: z.string().nullable(),
+});
+
+// ---------------------------------------------------------------------------
+// EventType / OrchestratorEvent (from src/lib/event-log.ts)
+// ---------------------------------------------------------------------------
+
+export const EventTypeSchemaZ = z.enum([
+  "dispatch",
+  "stall",
+  "completion",
+  "retry",
+  "reconcile",
+  "error",
+  "task_created",
+  "status_change",
+  "send",
+  "notify",
+  "milestone_validating",
+  "milestone_complete",
+  "validation_dispatch",
+  "remediation",
+  "validation_failed",
+  "planning",
+  "mission_complete",
+  "discovered_issue",
+  "research_dispatch",
+  "research_finding",
+  "agent_heartbeat",
+  "session_start",
+  "session_end",
+]);
+
+export const OrchestratorEventSchemaZ = z.object({
+  timestamp: z.string(),
+  type: EventTypeSchemaZ,
+  taskId: z.string().optional(),
+  agent: z.string().optional(),
+  message: z.string(),
+});
+
+// ---------------------------------------------------------------------------
+// StructuredEvent — discriminated union on "type" with typed payloads
+// ---------------------------------------------------------------------------
+
+const DispatchEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("dispatch"),
+  taskId: z.string(),
+  agent: z.string(),
+});
+
+const CompletionEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("completion"),
+  taskId: z.string(),
+  agent: z.string(),
+  durationMs: z.number().optional(),
+});
+
+const StallEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("stall"),
+  taskId: z.string(),
+  agent: z.string(),
+  elapsedMs: z.number(),
+});
+
+const RetryEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("retry"),
+  taskId: z.string(),
+  attempt: z.number(),
+  maxRetries: z.number(),
+  reason: z.string(),
+});
+
+const ReconcileEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("reconcile"),
+  taskId: z.string(),
+  previousAgent: z.string(),
+  action: z.string(),
+});
+
+const ErrorEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("error"),
+  taskId: z.string().optional(),
+  agent: z.string().optional(),
+  message: z.string(),
+  code: z.string().optional(),
+});
+
+const TaskCreatedEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("task_created"),
+  taskId: z.string(),
+  title: z.string(),
+});
+
+const StatusChangeEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("status_change"),
+  taskId: z.string(),
+  from: z.string(),
+  to: z.string(),
+});
+
+const SendEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("send"),
+  target: z.string(),
+  paneId: z.string(),
+  message: z.string(),
+});
+
+const NotifyEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("notify"),
+  target: z.string(),
+  paneId: z.string(),
+  message: z.string(),
+});
+
+const MilestoneValidatingEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("milestone_validating"),
+  milestoneId: z.string().optional(),
+  title: z.string().optional(),
+});
+
+const MilestoneCompleteEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("milestone_complete"),
+  milestoneId: z.string().optional(),
+  title: z.string().optional(),
+});
+
+const ValidationDispatchEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("validation_dispatch"),
+  milestoneId: z.string().optional(),
+  title: z.string().optional(),
+  target: z.string().optional(),
+});
+
+const RemediationEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("remediation"),
+  taskId: z.string(),
+  assertionId: z.string().optional(),
+});
+
+const ValidationFailedEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("validation_failed"),
+  milestoneId: z.string().optional(),
+  title: z.string().optional(),
+  failedCount: z.number().optional(),
+});
+
+const PlanningEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("planning"),
+  target: z.string().optional(),
+});
+
+const MissionCompleteEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("mission_complete"),
+  title: z.string().optional(),
+  milestoneCount: z.number().optional(),
+  taskCount: z.number().optional(),
+  prNumber: z.number().optional(),
+});
+
+const DiscoveredIssueEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("discovered_issue"),
+  taskId: z.string(),
+  sourceTaskId: z.string().optional(),
+  issue: z.string().optional(),
+});
+
+const ResearchDispatchEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("research_dispatch"),
+  taskId: z.string(),
+  target: z.string().optional(),
+  researchType: z.string().optional(),
+});
+
+const ResearchFindingEventZ = z.object({
+  timestamp: z.string(),
+  type: z.literal("research_finding"),
+  taskId: z.string(),
+  researchType: z.string().optional(),
+  summary: z.string().optional(),
+});
+
+export const StructuredEventSchemaZ = z.union([
+  DispatchEventZ,
+  CompletionEventZ,
+  StallEventZ,
+  RetryEventZ,
+  ReconcileEventZ,
+  ErrorEventZ,
+  TaskCreatedEventZ,
+  StatusChangeEventZ,
+  SendEventZ,
+  NotifyEventZ,
+  MilestoneValidatingEventZ,
+  MilestoneCompleteEventZ,
+  ValidationDispatchEventZ,
+  RemediationEventZ,
+  ValidationFailedEventZ,
+  PlanningEventZ,
+  MissionCompleteEventZ,
+  DiscoveredIssueEventZ,
+  ResearchDispatchEventZ,
+  ResearchFindingEventZ,
+]);
+
+// ---------------------------------------------------------------------------
+// MarkRange / Mark / AuthorshipStats (from src/lib/authorship.ts)
+// ---------------------------------------------------------------------------
+
+export const MarkRangeSchemaZ = z.object({
+  from: z.number(),
+  to: z.number(),
+});
+
+export const MarkSchemaZ = z.object({
+  id: z.string(),
+  kind: z.enum(["authored", "approved", "flagged", "comment", "insert", "delete", "replace"]),
+  by: z.string(),
+  at: z.string(),
+  range: MarkRangeSchemaZ,
+  quote: z.string(),
+  orphaned: z.boolean().optional(),
+});
+
+export const AuthorshipStatsSchemaZ = z.object({
+  aiPercent: z.number(),
+  humanPercent: z.number(),
+  totalChars: z.number(),
+});
+
+// ---------------------------------------------------------------------------
+// PlanStatus / PlanMeta (from src/lib/plan-store.ts)
+// ---------------------------------------------------------------------------
+
+export const PlanStatusSchemaZ = z.enum(["pending", "in-progress", "done", "archived"]);
+
+export const PlanMetaSchemaZ = z.object({
+  name: z.string(),
+  path: z.string(),
+  title: z.string(),
+  status: PlanStatusSchemaZ,
+  effort: z.string().optional(),
+  gate: z.string().optional(),
+  completed: z.string().optional(),
+});
+
+// ---------------------------------------------------------------------------
+// PaneInfo (from src/widgets/lib/pane-comms.ts)
+// ---------------------------------------------------------------------------
+
+export const PaneInfoSchemaZ = z.object({
+  id: z.string(),
+  index: z.number(),
+  title: z.string(),
+  currentCommand: z.string(),
+  width: z.number(),
+  height: z.number(),
+  active: z.boolean(),
+  role: z
+    .enum(["lead", "teammate", "planner", "validator", "researcher", "widget", "shell"])
+    .nullable(),
+  name: z.string().nullable(),
+  type: z.string().nullable(),
+});
+
+// ---------------------------------------------------------------------------
+// AgentDetail / SessionStats / SessionOverview / ProjectDetail
+// (from src/command-center/discovery.ts)
+// ---------------------------------------------------------------------------
+
+export const AgentDetailSchemaZ = z.object({
+  paneTitle: z.string(),
+  paneId: z.string(),
+  isBusy: z.boolean(),
+  taskTitle: z.string().nullable(),
+  taskId: z.string().nullable(),
+  elapsed: z.string(),
+});
+
+export const SessionStatsSchemaZ = z.object({
+  totalTasks: z.number(),
+  doneTasks: z.number(),
+  agents: z.number(),
+  activeAgents: z.number(),
+});
+
+export const SessionOverviewSchemaZ = z.object({
+  name: z.string(),
+  dir: z.string(),
+  mission: MissionSchemaZ.nullable(),
+  stats: SessionStatsSchemaZ,
+  goals: z.array(
+    z.object({
+      id: z.string(),
+      title: z.string(),
+      progress: z.number(),
+    }),
+  ),
+});
+
+export const ProjectDetailSchemaZ = z.object({
+  session: z.string(),
+  dir: z.string(),
+  mission: MissionSchemaZ.nullable(),
+  goals: z.array(GoalSchemaZ),
+  tasks: z.array(TaskSchemaZ),
+  agents: z.array(AgentDetailSchemaZ),
+});
+
+// ---------------------------------------------------------------------------
+// Inferred types
+// ---------------------------------------------------------------------------
+
+export type Mission = z.infer<typeof MissionSchemaZ>;
+export type Goal = z.infer<typeof GoalSchemaZ>;
+export type Task = z.infer<typeof TaskSchemaZ>;
+export type EventType = z.infer<typeof EventTypeSchemaZ>;
+export type Mark = z.infer<typeof MarkSchemaZ>;
+export type MarkRange = z.infer<typeof MarkRangeSchemaZ>;
+export type AuthorshipStats = z.infer<typeof AuthorshipStatsSchemaZ>;
+export type AgentDetail = z.infer<typeof AgentDetailSchemaZ>;
+export type SessionOverview = z.infer<typeof SessionOverviewSchemaZ>;
+export type ProjectDetail = z.infer<typeof ProjectDetailSchemaZ>;

package/src/schemas/ide-config.ts

@@ -0,0 +1,148 @@
+import { z } from "zod";
+import { AuthConfigSchema } from "../lib/auth/types.ts";
+import { HQConfigSchema } from "../lib/hq/types.ts";
+
+const sizeField = z
+  .string()
+  .regex(/^[1-9]\d*%$/)
+  .refine((v) => parseInt(v) <= 100);
+
+export const ThemeConfigSchema = z.object({
+  accent: z.string().optional(),
+  border: z.string().optional(),
+  bg: z.string().optional(),
+  fg: z.string().optional(),
+});
+
+export const PaneSchema = z.object({
+  title: z.string().optional(),
+  command: z.string().optional(),
+  type: z
+    .enum(["explorer", "changes", "preview", "tasks", "costs", "config", "mission-control"])
+    .optional(),
+  target: z.string().optional(),
+  dir: z.string().optional(),
+  size: sizeField.optional(),
+  focus: z.boolean().optional(),
+  env: z.record(z.string(), z.union([z.string(), z.number()])).optional(),
+  role: z.enum(["lead", "teammate", "planner", "validator", "researcher"]).optional(),
+  task: z.string().optional(),
+  specialty: z.string().optional(),
+  skill: z.string().optional(),
+});
+
+export const RowSchema = z.object({
+  size: sizeField.optional(),
+  panes: z.array(PaneSchema).min(1),
+});
+
+export const WebhookConfigSchema = z.object({
+  url: z.string(),
+  events: z.array(z.string()).optional(),
+  secret: z.string().optional(),
+});
+
+export const OrchestratorYamlConfigSchema = z.object({
+  enabled: z.boolean().optional(),
+  port: z.number().int().positive().optional(),
+  auto_dispatch: z.boolean().optional(),
+  stall_timeout: z.number().optional(),
+  poll_interval: z.number().min(100).optional(),
+  master_pane: z.string().optional(),
+  before_run: z.string().optional(),
+  after_run: z.string().optional(),
+  dispatch_mode: z.enum(["tasks", "goals", "missions"]).optional(),
+  max_concurrent_agents: z.number().min(1).max(50).optional(),
+  widgets: z.boolean().optional(),
+  webhooks: z.array(WebhookConfigSchema).optional(),
+  services: z
+    .record(
+      z.string(),
+      z.object({
+        command: z.string(),
+        port: z.number().optional(),
+        healthcheck: z.string().optional(),
+      }),
+    )
+    .optional(),
+  research: z
+    .object({
+      enabled: z.boolean().optional(),
+      triggers: z
+        .object({
+          mission_start: z.boolean().optional(),
+          milestone_progress: z.number().min(0).optional(),
+          milestone_complete: z.boolean().optional(),
+          periodic_minutes: z.number().min(0).optional(),
+          retry_cluster: z.boolean().optional(),
+          stall_detected: z.boolean().optional(),
+          discovered_issue: z.boolean().optional(),
+        })
+        .optional(),
+    })
+    .optional(),
+});
+
+export const TunnelConfigSchema = z.object({
+  provider: z.enum(["tailscale", "ngrok", "cloudflare"]),
+  auto_start: z.boolean().optional(),
+  port: z.number().int().positive().optional(),
+  domain: z.string().optional(),
+  authtoken: z.string().optional(),
+});
+
+export const CommandCenterConfigSchema = z.object({
+  port: z.number().optional(),
+  enabled: z.boolean().optional(),
+});
+
+export const DashboardConfigSchema = z.object({
+  port: z.number().int().positive().optional(),
+});
+
+export const IdeConfigSchema = z.object({
+  name: z.string().optional(),
+  before: z.string().optional(),
+  team: z
+    .object({
+      name: z.string(),
+      model: z.string().optional(),
+      permissions: z.array(z.string()).optional(),
+    })
+    .optional(),
+  rows: z.array(RowSchema).min(1),
+  theme: ThemeConfigSchema.optional(),
+  orchestrator: OrchestratorYamlConfigSchema.optional(),
+  command_center: CommandCenterConfigSchema.optional(),
+  dashboard: DashboardConfigSchema.optional(),
+  auth: AuthConfigSchema.optional(),
+  tunnel: TunnelConfigSchema.optional(),
+  hq: HQConfigSchema.optional(),
+});
+
+export const PaneActionSchema = z.object({
+  targetPane: z.string(),
+  title: z.string().nullable(),
+  chdir: z.string().nullable(),
+  exports: z.array(z.string()),
+  command: z.string().nullable(),
+  widgetType: z.string().nullable(),
+  widgetTarget: z.string().nullable(),
+  paneRole: z.string().nullable(),
+  paneType: z.string().nullable(),
+});
+
+export const SessionStateSchema = z.object({
+  running: z.boolean(),
+  reason: z.string().nullable(),
+});
+
+export type ThemeConfig = z.infer<typeof ThemeConfigSchema>;
+export type Pane = z.infer<typeof PaneSchema>;
+export type Row = z.infer<typeof RowSchema>;
+export type OrchestratorYamlConfig = z.infer<typeof OrchestratorYamlConfigSchema>;
+export type CommandCenterConfig = z.infer<typeof CommandCenterConfigSchema>;
+export type DashboardConfig = z.infer<typeof DashboardConfigSchema>;
+export type IdeConfig = z.infer<typeof IdeConfigSchema>;
+export type PaneAction = z.infer<typeof PaneActionSchema>;
+export type SessionState = z.infer<typeof SessionStateSchema>;

package/src/schemas/index.ts

@@ -0,0 +1,53 @@
+export {
+  PaneSchema,
+  RowSchema,
+  ThemeConfigSchema,
+  OrchestratorYamlConfigSchema,
+  IdeConfigSchema,
+  PaneActionSchema,
+  SessionStateSchema,
+} from "./ide-config.ts";
+
+export type {
+  Pane,
+  Row,
+  ThemeConfig,
+  OrchestratorYamlConfig,
+  IdeConfig,
+  PaneAction,
+  SessionState,
+} from "./ide-config.ts";
+
+export {
+  ProofSchemaZ,
+  TaskSchemaZ,
+  GoalSchemaZ,
+  MissionSchemaZ,
+  EventTypeSchemaZ,
+  OrchestratorEventSchemaZ,
+  MarkRangeSchemaZ,
+  MarkSchemaZ,
+  AuthorshipStatsSchemaZ,
+  PlanStatusSchemaZ,
+  PlanMetaSchemaZ,
+  AgentDetailSchemaZ,
+  SessionOverviewSchemaZ,
+  ProjectDetailSchemaZ,
+  SessionStatsSchemaZ,
+  PaneInfoSchemaZ,
+  StructuredEventSchemaZ,
+} from "./domain.ts";
+
+export type {
+  ProofSchema,
+  Mission,
+  Goal,
+  Task,
+  EventType,
+  Mark,
+  MarkRange,
+  AuthorshipStats,
+  AgentDetail,
+  SessionOverview,
+  ProjectDetail,
+} from "./domain.ts";

package/src/send.test.ts

@@ -0,0 +1,70 @@
+import { describe, it, beforeEach, afterEach, expect } from "bun:test";
+import { mkdtempSync, rmSync, existsSync, readFileSync, mkdirSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { writeDispatchFile, LONG_MESSAGE_THRESHOLD } from "./send.ts";
+
+let tmpDir: string;
+
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(tmpdir(), "tmux-ide-send-test-"));
+  mkdirSync(join(tmpDir, ".tasks"), { recursive: true });
+});
+
+afterEach(() => {
+  rmSync(tmpDir, { recursive: true, force: true });
+});
+
+describe("writeDispatchFile", () => {
+  it("writes long message to dispatch file and returns trigger command", () => {
+    const longMessage = "x".repeat(200);
+    const result = writeDispatchFile(tmpDir, "%1", longMessage);
+
+    expect(result).not.toBeNull();
+    expect(result!.triggerCmd).toContain(".tasks/dispatch/");
+    expect(result!.triggerCmd).toContain("send-1-");
+    expect(existsSync(result!.filePath)).toBe(true);
+    expect(readFileSync(result!.filePath, "utf-8")).toBe(longMessage);
+  });
+
+  it("returns null for short messages", () => {
+    const result = writeDispatchFile(tmpDir, "%1", "hello");
+    expect(result).toBeNull();
+  });
+
+  it("returns null for messages exactly at threshold", () => {
+    const result = writeDispatchFile(tmpDir, "%1", "x".repeat(LONG_MESSAGE_THRESHOLD));
+    expect(result).toBeNull();
+  });
+
+  it("creates dispatch directory if it does not exist", () => {
+    const longMessage = "y".repeat(200);
+    const result = writeDispatchFile(tmpDir, "%2", longMessage);
+    expect(result).not.toBeNull();
+    expect(existsSync(join(tmpDir, ".tasks", "dispatch"))).toBe(true);
+  });
+
+  it("creates unique filenames for different panes", () => {
+    const msg = "z".repeat(200);
+    const r1 = writeDispatchFile(tmpDir, "%1", msg);
+    const r2 = writeDispatchFile(tmpDir, "%2", msg);
+    expect(r1).not.toBeNull();
+    expect(r2).not.toBeNull();
+    expect(r1!.filePath).not.toBe(r2!.filePath);
+  });
+
+  it("adds a random suffix so same-pane writes stay unique in the same millisecond", () => {
+    const originalNow = Date.now;
+    Date.now = () => 1234567890;
+    try {
+      const msg = "z".repeat(200);
+      const r1 = writeDispatchFile(tmpDir, "%1", msg);
+      const r2 = writeDispatchFile(tmpDir, "%1", msg);
+      expect(r1).not.toBeNull();
+      expect(r2).not.toBeNull();
+      expect(r1!.filePath).not.toBe(r2!.filePath);
+    } finally {
+      Date.now = originalNow;
+    }
+  });
+});