@ronkovic/aad 0.3.0

package/src/shared/__tests__/types.test.ts

@@ -0,0 +1,360 @@
+import { describe, test, expect } from "bun:test";
+import {
+  createTaskId,
+  createWorkerId,
+  createRunId,
+  createRepoName,
+  type TaskId,
+  type WorkerId,
+  type RunId,
+  type TaskStatus,
+  type EffortLevel,
+  type PhaseName,
+  type ProgressState,
+  type TaskExecutionResult,
+  type Task,
+  type Worker,
+  type WorkerStatus,
+  type RunState,
+  type TaskPlan,
+} from "../types";
+
+describe("Branded Types", () => {
+  test("createTaskId creates valid TaskId", () => {
+    const id = createTaskId("task-001");
+    expect(id as string).toBe("task-001");
+  });
+
+  test("createTaskId rejects empty string", () => {
+    expect(() => createTaskId("")).toThrow("cannot be empty");
+  });
+
+  test("createWorkerId creates valid WorkerId", () => {
+    const id = createWorkerId("worker-1");
+    expect(id as string).toBe("worker-1");
+  });
+
+  test("createWorkerId rejects empty string", () => {
+    expect(() => createWorkerId("")).toThrow("cannot be empty");
+  });
+
+  test("createRunId creates valid RunId", () => {
+    const id = createRunId("run-123");
+    expect(id as string).toBe("run-123");
+  });
+
+  test("createRunId rejects empty string", () => {
+    expect(() => createRunId("")).toThrow("cannot be empty");
+  });
+
+  test("createRepoName creates valid RepoName", () => {
+    const name = createRepoName("my-repo");
+    expect(name as string).toBe("my-repo");
+  });
+
+  test("createRepoName rejects empty string", () => {
+    expect(() => createRepoName("")).toThrow("cannot be empty");
+  });
+
+  test("createRepoName rejects invalid characters", () => {
+    expect(() => createRepoName("my repo")).toThrow("alphanumeric");
+    expect(() => createRepoName("my/repo")).toThrow("alphanumeric");
+  });
+
+  test("branded types are string-compatible", () => {
+    const taskId: TaskId = createTaskId("t1");
+    const workerId: WorkerId = createWorkerId("w1");
+    const runId: RunId = createRunId("r1");
+
+    expect(typeof taskId).toBe("string");
+    expect(typeof workerId).toBe("string");
+    expect(typeof runId).toBe("string");
+  });
+});
+
+describe("TaskStatus", () => {
+  test("accepts valid status values", () => {
+    const statuses: TaskStatus[] = ["pending", "running", "completed", "failed"];
+    statuses.forEach((status) => {
+      expect(["pending", "running", "completed", "failed"]).toContain(status);
+    });
+  });
+});
+
+describe("EffortLevel", () => {
+  test("accepts valid effort levels", () => {
+    const levels: EffortLevel[] = ["low", "medium", "high"];
+    levels.forEach((level) => {
+      expect(["low", "medium", "high"]).toContain(level);
+    });
+  });
+});
+
+describe("PhaseName", () => {
+  test("accepts valid phase names", () => {
+    const phases: PhaseName[] = [
+      "splitter",
+      "tester",
+      "implementer",
+      "reviewer",
+      "merge-resolver",
+    ];
+    phases.forEach((phase) => {
+      expect([
+        "splitter",
+        "tester",
+        "implementer",
+        "reviewer",
+        "merge-resolver",
+      ]).toContain(phase);
+    });
+  });
+});
+
+describe("ProgressState", () => {
+  test("creates valid ProgressState", () => {
+    const state: ProgressState = {
+      total: 10,
+      pending: 5,
+      running: 3,
+      completed: 2,
+      failed: 0,
+    };
+
+    expect(state.total).toBe(10);
+    expect(state.pending).toBe(5);
+    expect(state.running).toBe(3);
+    expect(state.completed).toBe(2);
+    expect(state.failed).toBe(0);
+  });
+});
+
+describe("TaskExecutionResult", () => {
+  test("creates successful result", () => {
+    const result: TaskExecutionResult = {
+      taskId: createTaskId("t1"),
+      status: "completed",
+      duration: 1500,
+      output: "Task completed successfully",
+    };
+
+    expect(result.taskId as string).toBe("t1");
+    expect(result.status).toBe("completed");
+    expect(result.duration).toBe(1500);
+    expect(result.output).toBe("Task completed successfully");
+    expect(result.error).toBeUndefined();
+  });
+
+  test("creates failed result with error", () => {
+    const result: TaskExecutionResult = {
+      taskId: createTaskId("t2"),
+      status: "failed",
+      duration: 500,
+      error: "Timeout exceeded",
+    };
+
+    expect(result.taskId as string).toBe("t2");
+    expect(result.status).toBe("failed");
+    expect(result.error).toBe("Timeout exceeded");
+  });
+});
+
+describe("Task", () => {
+  test("creates valid task with all required fields", () => {
+    const task: Task = {
+      taskId: createTaskId("task-1"),
+      title: "Implement feature X",
+      description: "Add new feature X to the system",
+      filesToModify: ["src/feature-x.ts", "src/types.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "pending",
+      retryCount: 0,
+    };
+
+    expect(task.taskId as string).toBe("task-1");
+    expect(task.title).toBe("Implement feature X");
+    expect(task.filesToModify).toHaveLength(2);
+    expect(task.dependsOn).toHaveLength(0);
+    expect(task.status).toBe("pending");
+    expect(task.retryCount).toBe(0);
+  });
+
+  test("creates task with dependencies", () => {
+    const task: Task = {
+      taskId: createTaskId("task-2"),
+      title: "Task 2",
+      description: "Depends on task-1",
+      filesToModify: [],
+      dependsOn: [createTaskId("task-1")],
+      priority: 2,
+      status: "pending",
+      retryCount: 0,
+    };
+
+    expect(task.dependsOn).toHaveLength(1);
+    expect(task.dependsOn[0] as string).toBe("task-1");
+  });
+
+  test("creates task with optional fields", () => {
+    const now = new Date().toISOString();
+    const task: Task = {
+      taskId: createTaskId("task-3"),
+      title: "Task 3",
+      description: "Running task",
+      filesToModify: ["file.ts"],
+      dependsOn: [],
+      priority: 1,
+      status: "running",
+      workerId: createWorkerId("worker-1"),
+      startTime: now,
+      retryCount: 1,
+      failureReason: "Previous timeout",
+    };
+
+    expect(task.workerId as string).toBe("worker-1");
+    expect(task.startTime).toBe(now);
+    expect(task.retryCount).toBe(1);
+    expect(task.failureReason).toBe("Previous timeout");
+  });
+});
+
+describe("WorkerStatus", () => {
+  test("accepts valid worker status values", () => {
+    const statuses: WorkerStatus[] = ["idle", "busy", "stopped"];
+    statuses.forEach((status) => {
+      expect(["idle", "busy", "stopped"]).toContain(status);
+    });
+  });
+});
+
+describe("Worker", () => {
+  test("creates idle worker", () => {
+    const worker: Worker = {
+      workerId: createWorkerId("worker-1"),
+      status: "idle",
+      currentTask: null,
+    };
+
+    expect(worker.workerId as string).toBe("worker-1");
+    expect(worker.status).toBe("idle");
+    expect(worker.currentTask).toBeNull();
+  });
+
+  test("creates busy worker with task", () => {
+    const worker: Worker = {
+      workerId: createWorkerId("worker-2"),
+      status: "busy",
+      currentTask: createTaskId("task-1"),
+      pid: 12345,
+    };
+
+    expect(worker.status).toBe("busy");
+    expect(worker.currentTask as string).toBe("task-1");
+    expect(worker.pid).toBe(12345);
+  });
+
+  test("creates stopped worker", () => {
+    const worker: Worker = {
+      workerId: createWorkerId("worker-3"),
+      status: "stopped",
+      currentTask: null,
+    };
+
+    expect(worker.status).toBe("stopped");
+  });
+});
+
+describe("RunState", () => {
+  test("creates valid run state", () => {
+    const now = new Date().toISOString();
+    const runState: RunState = {
+      runId: createRunId("run-123"),
+      parentBranch: "main",
+      totalTasks: 10,
+      pending: 5,
+      running: 3,
+      completed: 2,
+      failed: 0,
+      startTime: now,
+    };
+
+    expect(runState.runId as string).toBe("run-123");
+    expect(runState.parentBranch).toBe("main");
+    expect(runState.totalTasks).toBe(10);
+    expect(runState.pending + runState.running + runState.completed + runState.failed).toBe(10);
+    expect(runState.startTime).toBe(now);
+    expect(runState.endTime).toBeUndefined();
+  });
+
+  test("creates completed run state with end time", () => {
+    const start = new Date().toISOString();
+    const end = new Date(Date.now() + 3600000).toISOString();
+    const runState: RunState = {
+      runId: createRunId("run-124"),
+      parentBranch: "feat/new-feature",
+      totalTasks: 5,
+      pending: 0,
+      running: 0,
+      completed: 4,
+      failed: 1,
+      startTime: start,
+      endTime: end,
+    };
+
+    expect(runState.completed).toBe(4);
+    expect(runState.failed).toBe(1);
+    expect(runState.endTime).toBe(end);
+  });
+});
+
+describe("TaskPlan", () => {
+  test("creates valid task plan", () => {
+    const taskPlan: TaskPlan = {
+      runId: createRunId("run-125"),
+      parentBranch: "main",
+      title: "Add authentication",
+      description: "Implement JWT-based authentication",
+      tasks: [
+        {
+          taskId: createTaskId("task-1"),
+          title: "Setup JWT library",
+          description: "Install and configure JWT library",
+          filesToModify: ["package.json", "src/auth/jwt.ts"],
+          dependsOn: [],
+          priority: 1,
+          status: "pending",
+          retryCount: 0,
+        },
+        {
+          taskId: createTaskId("task-2"),
+          title: "Add login endpoint",
+          description: "Create POST /auth/login endpoint",
+          filesToModify: ["src/routes/auth.ts"],
+          dependsOn: [createTaskId("task-1")],
+          priority: 2,
+          status: "pending",
+          retryCount: 0,
+        },
+      ],
+    };
+
+    expect(taskPlan.runId as string).toBe("run-125");
+    expect(taskPlan.title).toBe("Add authentication");
+    expect(taskPlan.tasks).toHaveLength(2);
+    expect(taskPlan.tasks[0]?.taskId as string).toBe("task-1");
+    expect(taskPlan.tasks[1]?.dependsOn).toHaveLength(1);
+  });
+
+  test("creates minimal task plan without title/description", () => {
+    const taskPlan: TaskPlan = {
+      runId: createRunId("run-126"),
+      parentBranch: "develop",
+      tasks: [],
+    };
+
+    expect(taskPlan.tasks).toHaveLength(0);
+    expect(taskPlan.title).toBeUndefined();
+    expect(taskPlan.description).toBeUndefined();
+  });
+});

package/src/shared/config.ts

@@ -0,0 +1,133 @@
+import { z } from "zod";
+import { ConfigError } from "./errors";
+
+const configSchema = z.object({
+  workers: z.object({
+    num: z.number().int().min(1),
+    max: z.number().int().min(1),
+  }),
+  models: z.object({
+    default: z.string().optional(),
+    splitter: z.string().optional(),
+    tester: z.string().optional(),
+    implementer: z.string().optional(),
+    reviewer: z.string().optional(),
+    mergeResolver: z.string().optional(),
+    branchName: z.string().optional(),
+  }),
+  timeouts: z.object({
+    claude: z.number().int().min(1),
+    test: z.number().int().min(1),
+    staleTask: z.number().int().min(1),
+  }),
+  retry: z.object({
+    maxRetries: z.number().int().min(0),
+  }),
+  debug: z.boolean(),
+  adaptiveEffort: z.boolean(),
+  teams: z.object({
+    splitter: z.boolean(),
+    reviewer: z.boolean(),
+  }),
+  memorySync: z.boolean(),
+  auth: z.object({
+    preferOAuth: z.boolean(),
+  }).optional(),
+  dashboard: z.object({
+    enabled: z.boolean(),
+    port: z.number().int().min(1).max(65535),
+    host: z.string(),
+  }),
+  repos: z.array(z.object({
+    name: z.string().optional(),
+    path: z.string(),
+    ref: z.string().optional(),
+  })).optional(),
+  multiRepoStrategy: z.enum(["independent", "coordinated"]).optional(),
+  plugins: z.array(z.string()).optional(),
+});
+
+export type Config = z.infer<typeof configSchema>;
+
+function parseIntOrDefault(value: string | undefined, defaultValue: number): number {
+  if (!value) return defaultValue;
+  const parsed = parseInt(value, 10);
+  if (isNaN(parsed)) {
+    throw new ConfigError(`Invalid number: ${value}`);
+  }
+  return parsed;
+}
+
+function parseBoolOrDefault(value: string | undefined, defaultValue: boolean): boolean {
+  if (!value) return defaultValue;
+  return value === "1" || value.toLowerCase() === "true";
+}
+
+export function loadConfig(env: Record<string, string | undefined> = process.env): Config {
+  const numWorkers = parseIntOrDefault(env.AAD_NUM_WORKERS, 2);
+  const maxWorkers = parseIntOrDefault(env.AAD_MAX_WORKERS, 8);
+
+  if (numWorkers > maxWorkers) {
+    throw new ConfigError(
+      `AAD_NUM_WORKERS (${numWorkers}) exceeds AAD_MAX_WORKERS (${maxWorkers})`,
+      { numWorkers, maxWorkers }
+    );
+  }
+
+  const rawConfig = {
+    workers: {
+      num: numWorkers,
+      max: maxWorkers,
+    },
+    models: {
+      default: env.AAD_MODEL,
+      splitter: env.AAD_MODEL_SPLITTER,
+      tester: env.AAD_MODEL_TESTER,
+      implementer: env.AAD_MODEL_IMPLEMENTER,
+      reviewer: env.AAD_MODEL_REVIEWER,
+      mergeResolver: env.AAD_MODEL_MERGE,
+      branchName: env.AAD_MODEL_BRANCH_NAME,
+    },
+    timeouts: {
+      claude: parseIntOrDefault(env.CLAUDE_TIMEOUT, 1200),
+      test: parseIntOrDefault(env.TEST_TIMEOUT, 600),
+      staleTask: parseIntOrDefault(env.AAD_STALE_TASK_TIMEOUT, 5400),
+    },
+    retry: {
+      maxRetries: parseIntOrDefault(env.MAX_PHASE_RETRIES, 2),
+    },
+    debug: parseBoolOrDefault(env.DEBUG, false),
+    adaptiveEffort: parseBoolOrDefault(env.AAD_ADAPTIVE_EFFORT, false),
+    teams: {
+      splitter: parseBoolOrDefault(env.AAD_USE_TEAMS_FOR_SPLITTER, false),
+      reviewer: parseBoolOrDefault(env.AAD_USE_TEAMS_FOR_REVIEW, false),
+    },
+    memorySync: parseBoolOrDefault(env.AAD_MEMORY_SYNC_ENABLED, true),
+    auth: {
+      preferOAuth: parseBoolOrDefault(env.AAD_AUTH_PREFER_OAUTH, false),
+    },
+    dashboard: {
+      enabled: parseBoolOrDefault(env.AAD_DASHBOARD_ENABLED, true),
+      port: parseIntOrDefault(env.AAD_DASHBOARD_PORT, 7333),
+      host: env.AAD_DASHBOARD_HOST ?? "localhost",
+    },
+    repos: env.AAD_REPOS
+      ? env.AAD_REPOS.split(",").map((p) => ({ path: p.trim() }))
+      : undefined,
+    multiRepoStrategy: env.AAD_MULTI_REPO_STRATEGY as "independent" | "coordinated" | undefined,
+    plugins: env.AAD_PLUGINS
+      ? env.AAD_PLUGINS.split(",").map((p) => p.trim()).filter(Boolean)
+      : undefined,
+  };
+
+  try {
+    return configSchema.parse(rawConfig);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      throw new ConfigError(`Invalid configuration: ${error.message}`, {
+        errors: error.errors,
+      });
+    }
+    throw error;
+  }
+}

package/src/shared/errors.ts

@@ -0,0 +1,128 @@
+export class AadError extends Error {
+  public readonly code: string;
+  public readonly context: Record<string, unknown>;
+
+  constructor(
+    code: string,
+    message: string,
+    context: Record<string, unknown> = {}
+  ) {
+    super(message);
+    this.code = code;
+    this.context = context;
+    this.name = "AadError";
+    Error.captureStackTrace(this, this.constructor);
+  }
+}
+
+export class ConfigError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("CONFIG_ERROR", message, context);
+    this.name = "ConfigError";
+  }
+}
+
+export class ClaudeProviderError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("CLAUDE_PROVIDER_ERROR", message, context);
+    this.name = "ClaudeProviderError";
+  }
+}
+
+export class TimeoutError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("TIMEOUT_ERROR", message, context);
+    this.name = "TimeoutError";
+  }
+}
+
+export class ValidationError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("VALIDATION_ERROR", message, context);
+    this.name = "ValidationError";
+  }
+}
+
+export class DashboardError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("DASHBOARD_ERROR", message, context);
+    this.name = "DashboardError";
+  }
+}
+
+export class PersistenceError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("PERSISTENCE_ERROR", message, context);
+    this.name = "PersistenceError";
+  }
+}
+
+export class FileLockError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("FILE_LOCK_ERROR", message, context);
+    this.name = "FileLockError";
+  }
+}
+
+export class TaskQueueError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("TASK_QUEUE_ERROR", message, context);
+    this.name = "TaskQueueError";
+  }
+}
+
+export class CircularDependencyError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("CIRCULAR_DEPENDENCY_ERROR", message, context);
+    this.name = "CircularDependencyError";
+  }
+}
+
+export class GitWorkspaceError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("GIT_WORKSPACE_ERROR", message, context);
+    this.name = "GitWorkspaceError";
+  }
+}
+
+export class ProcessManagerError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("PROCESS_MANAGER_ERROR", message, context);
+    this.name = "ProcessManagerError";
+  }
+}
+
+export class PlanningError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("PLANNING_ERROR", message, context);
+    this.name = "PlanningError";
+  }
+}
+
+export class TaskExecutionError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("TASK_EXECUTION_ERROR", message, context);
+    this.name = "TaskExecutionError";
+  }
+}
+
+export class PhaseError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("PHASE_ERROR", message, context);
+    this.name = "PhaseError";
+  }
+}
+
+export class TestRunnerError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("TEST_RUNNER_ERROR", message, context);
+    this.name = "TestRunnerError";
+  }
+}
+
+export class MergeConflictError extends AadError {
+  constructor(message: string, context: Record<string, unknown> = {}) {
+    super("MERGE_CONFLICT_ERROR", message, context);
+    this.name = "MergeConflictError";
+  }
+}