@ronkovic/aad 0.3.0

package/src/shared/events.ts

@@ -0,0 +1,171 @@
+import { EventEmitter } from "node:events";
+import type {
+  TaskId,
+  WorkerId,
+  RunId,
+  ProgressState,
+  TaskExecutionResult,
+} from "./types";
+
+export type AADEvent =
+  | {
+      type: "task:dispatched";
+      taskId: TaskId;
+      workerId: WorkerId;
+    }
+  | {
+      type: "task:completed";
+      taskId: TaskId;
+      result: TaskExecutionResult;
+    }
+  | {
+      type: "task:failed";
+      taskId: TaskId;
+      error: string;
+    }
+  | {
+      type: "task:stale";
+      taskId: TaskId;
+      elapsed: number;
+    }
+  | {
+      type: "task:retry";
+      taskId: TaskId;
+      retryCount: number;
+    }
+  | {
+      type: "worker:idle";
+      workerId: WorkerId;
+    }
+  | {
+      type: "worker:started";
+      workerId: WorkerId;
+    }
+  | {
+      type: "worker:stopped";
+      workerId: WorkerId;
+    }
+  | {
+      type: "worker:busy";
+      workerId: WorkerId;
+      taskId: TaskId;
+    }
+  | {
+      type: "queue:initialized";
+      totalTasks: number;
+    }
+  | {
+      type: "queue:empty";
+    }
+  | {
+      type: "progress:updated";
+      state: ProgressState;
+    }
+  | {
+      type: "run:completed";
+      runId: RunId;
+    }
+  | {
+      type: "run:failed";
+      runId: RunId;
+      error: string;
+    }
+  | {
+      type: "log:entry";
+      entry: {
+        level: string;
+        service: string;
+        message: string;
+        timestamp: number;
+        [key: string]: unknown;
+      };
+    }
+  | {
+      type: "planning:started";
+      requirementsPath: string;
+    }
+  | {
+      type: "planning:completed";
+      taskCount: number;
+    }
+  | {
+      type: "planning:failed";
+      error: string;
+    }
+  | {
+      type: "execution:started";
+      taskId: TaskId;
+    }
+  | {
+      type: "execution:completed";
+      taskId: TaskId;
+      duration: number;
+    }
+  | {
+      type: "execution:phase:started";
+      taskId: TaskId;
+      phase: string;
+    }
+  | {
+      type: "execution:phase:completed";
+      taskId: TaskId;
+      phase: string;
+      duration: number;
+    }
+  | {
+      type: "execution:phase:failed";
+      taskId: TaskId;
+      phase: string;
+      error: string;
+    }
+  | {
+      type: "execution:merge:conflict";
+      taskId: TaskId;
+      conflictedFiles: string[];
+    };
+
+export type EventType = AADEvent["type"] | "*";
+export type EventListener<T extends AADEvent = AADEvent> = (event: T) => void;
+
+export class EventBus {
+  private emitter: EventEmitter;
+  private listenerMap: WeakMap<EventListener<AADEvent>, EventListener<AADEvent>>;
+
+  constructor() {
+    this.emitter = new EventEmitter();
+    this.emitter.setMaxListeners(100);
+    this.listenerMap = new WeakMap();
+  }
+
+  on<T extends AADEvent>(
+    type: T["type"] | "*",
+    listener: EventListener<T>
+  ): void {
+    const wrappedListener = (event: AADEvent): void => {
+      try {
+        listener(event as T);
+      } catch (error) {
+        console.error(`EventBus listener error for ${type}:`, error);
+      }
+    };
+
+    this.listenerMap.set(listener as EventListener<AADEvent>, wrappedListener);
+    this.emitter.on(type, wrappedListener);
+  }
+
+  emit(event: AADEvent): void {
+    this.emitter.emit(event.type, event);
+    this.emitter.emit("*", event);
+  }
+
+  off<T extends AADEvent>(
+    type: T["type"] | "*",
+    listener: EventListener<T>
+  ): void {
+    const wrappedListener = this.listenerMap.get(listener as EventListener<AADEvent>);
+    if (wrappedListener) {
+      this.emitter.off(type, wrappedListener);
+      this.listenerMap.delete(listener as EventListener<AADEvent>);
+    }
+  }
+}

package/src/shared/types.ts

@@ -0,0 +1,143 @@
+// Branded Types
+export type TaskId = string & { readonly __brand: "TaskId" };
+export type WorkerId = string & { readonly __brand: "WorkerId" };
+export type RunId = string & { readonly __brand: "RunId" };
+
+export function createTaskId(id: string): TaskId {
+  if (!id || id.trim() === "") {
+    throw new Error("TaskId cannot be empty");
+  }
+  return id as TaskId;
+}
+
+export function createWorkerId(id: string): WorkerId {
+  if (!id || id.trim() === "") {
+    throw new Error("WorkerId cannot be empty");
+  }
+  return id as WorkerId;
+}
+
+export function createRunId(id: string): RunId {
+  if (!id || id.trim() === "") {
+    throw new Error("RunId cannot be empty");
+  }
+  return id as RunId;
+}
+
+// Task Status
+export type TaskStatus = "pending" | "running" | "completed" | "failed";
+
+// Effort Levels
+export type EffortLevel = "low" | "medium" | "high";
+
+// Phase Names
+export type PhaseName =
+  | "splitter"
+  | "tester"
+  | "implementer"
+  | "reviewer"
+  | "merge-resolver";
+
+// Progress State
+export interface ProgressState {
+  total: number;
+  pending: number;
+  running: number;
+  completed: number;
+  failed: number;
+}
+
+// Task Execution Result
+export interface TaskExecutionResult {
+  taskId: TaskId;
+  status: TaskStatus;
+  duration: number;
+  output?: string;
+  error?: string;
+}
+
+// RepoName branded type
+export type RepoName = string & { readonly __brand: "RepoName" };
+
+export function createRepoName(name: string): RepoName {
+  if (!name || name.trim() === "") {
+    throw new Error("RepoName cannot be empty");
+  }
+  if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error("RepoName must contain only alphanumeric characters, hyphens, and underscores");
+  }
+  return name as RepoName;
+}
+
+// Task (full domain model)
+export interface Task {
+  taskId: TaskId;
+  title: string;
+  description: string;
+  filesToModify: string[];
+  dependsOn: TaskId[];
+  priority: number;
+  status: TaskStatus;
+  workerId?: WorkerId;
+  startTime?: string;
+  endTime?: string;
+  retryCount: number;
+  failureReason?: string;
+  repoName?: RepoName;
+}
+
+// Worker Status
+export type WorkerStatus = "idle" | "busy" | "stopped";
+
+export interface Worker {
+  workerId: WorkerId;
+  status: WorkerStatus;
+  currentTask: TaskId | null;
+  pid?: number;
+}
+
+// Run State
+export interface RunState {
+  runId: RunId;
+  parentBranch: string;
+  totalTasks: number;
+  pending: number;
+  running: number;
+  completed: number;
+  failed: number;
+  startTime: string;
+  endTime?: string;
+}
+
+// Task Plan
+export interface TaskPlan {
+  runId: RunId;
+  parentBranch: string;
+  title?: string;
+  description?: string;
+  tasks: Task[];
+}
+
+// Test Framework Types
+export type TestFramework =
+  | "bun-test"
+  | "vitest"
+  | "jest"
+  | "mocha"
+  | "pytest"
+  | "go-test"
+  | "cargo"
+  | "maven"
+  | "gradle"
+  | "unknown";
+
+// Workspace Info (from project detection)
+export interface WorkspaceInfo {
+  path: string;
+  language: string;
+  packageManager: string;
+  framework: string;
+  testFramework: TestFramework;
+  orm?: string;
+  architecturePattern?: string;
+}

package/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "allowJs": true,
+
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+
+    "paths": {
+      "@aad/shared/*": ["./src/shared/*"],
+      "@aad/*": ["./src/modules/*"]
+    },
+    "baseUrl": "."
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": ["node_modules", "dist"]
+}