mcoda 0.1.2 → 0.1.4

package/packages/core/src/services/estimate/VelocityService.ts

@@ -1,272 +0,0 @@
-import fs from "node:fs/promises";
-import path from "node:path";
-import { Connection, type Database } from "@mcoda/db";
-import { PathHelper } from "@mcoda/shared";
-import { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
-import type { EffectiveVelocity, VelocityConfig, VelocityOptions, VelocityScopeIds } from "./types.js";
-
-const DEFAULT_SP_PER_HOUR = 15;
-const DEFAULT_ALPHA = 0.5;
-
-export class VelocityService {
-  private constructor(
-    private workspace: WorkspaceResolution,
-    private db: Database,
-    private connection: Connection,
-    private globalVelocity?: VelocityConfig,
-  ) {}
-
-  static async create(workspace: WorkspaceResolution): Promise<VelocityService> {
-    const dbPath = PathHelper.getWorkspaceDbPath(workspace.workspaceRoot);
-    const connection = await Connection.open(dbPath);
-    const globalVelocity = await VelocityService.readGlobalVelocityConfig();
-    return new VelocityService(workspace, connection.db, connection, globalVelocity);
-  }
-
-  async close(): Promise<void> {
-    await this.connection.close();
-  }
-
-  private static async readGlobalVelocityConfig(): Promise<VelocityConfig | undefined> {
-    const configPath = path.join(PathHelper.getGlobalMcodaDir(), "config.json");
-    try {
-      const raw = await fs.readFile(configPath, "utf8");
-      const parsed = JSON.parse(raw) as { velocity?: Partial<VelocityConfig> };
-      if (!parsed.velocity) return undefined;
-      return {
-        implementationSpPerHour: parsed.velocity.implementationSpPerHour ?? DEFAULT_SP_PER_HOUR,
-        reviewSpPerHour: parsed.velocity.reviewSpPerHour ?? DEFAULT_SP_PER_HOUR,
-        qaSpPerHour: parsed.velocity.qaSpPerHour ?? DEFAULT_SP_PER_HOUR,
-        alpha: parsed.velocity.alpha ?? DEFAULT_ALPHA,
-      };
-    } catch {
-      return undefined;
-    }
-  }
-
-  private resolveConfig(options: VelocityOptions): VelocityConfig {
-    const base: VelocityConfig = {
-      implementationSpPerHour: DEFAULT_SP_PER_HOUR,
-      reviewSpPerHour: DEFAULT_SP_PER_HOUR,
-      qaSpPerHour: DEFAULT_SP_PER_HOUR,
-      alpha: DEFAULT_ALPHA,
-    };
-    // Global config first
-    if (this.globalVelocity) {
-      base.implementationSpPerHour = this.globalVelocity.implementationSpPerHour ?? base.implementationSpPerHour;
-      base.reviewSpPerHour = this.globalVelocity.reviewSpPerHour ?? base.reviewSpPerHour;
-      base.qaSpPerHour = this.globalVelocity.qaSpPerHour ?? base.qaSpPerHour;
-      base.alpha = this.globalVelocity.alpha ?? base.alpha;
-    }
-    // Workspace config overrides global
-    if (this.workspace.config?.velocity) {
-      base.implementationSpPerHour =
-        this.workspace.config.velocity.implementationSpPerHour ?? base.implementationSpPerHour;
-      base.reviewSpPerHour = this.workspace.config.velocity.reviewSpPerHour ?? base.reviewSpPerHour;
-      base.qaSpPerHour = this.workspace.config.velocity.qaSpPerHour ?? base.qaSpPerHour;
-      base.alpha = this.workspace.config.velocity.alpha ?? base.alpha;
-    }
-    if (options.spPerHourAll !== undefined) {
-      base.implementationSpPerHour = options.spPerHourAll;
-      base.reviewSpPerHour = options.spPerHourAll;
-      base.qaSpPerHour = options.spPerHourAll;
-    }
-    if (options.spPerHourReview !== undefined) {
-      base.reviewSpPerHour = options.spPerHourReview;
-    }
-    if (options.spPerHourQa !== undefined) {
-      base.qaSpPerHour = options.spPerHourQa;
-    }
-    return base;
-  }
-
-  private async resolveScopeIds(options: VelocityOptions): Promise<VelocityScopeIds> {
-    const scope: VelocityScopeIds = {};
-    if (options.projectKey) {
-      const row = await this.db.get<{ id: string } | undefined>(`SELECT id FROM projects WHERE key = ?`, options.projectKey);
-      if (!row) {
-        throw new Error(`Unknown project key: ${options.projectKey}`);
-      }
-      scope.projectId = row.id;
-    }
-    if (options.epicKey) {
-      const row = await this.db.get<{ id: string } | undefined>(
-        `SELECT id FROM epics WHERE key = ? ${scope.projectId ? "AND project_id = ?" : ""}`,
-        scope.projectId ? [options.epicKey, scope.projectId] : [options.epicKey],
-      );
-      if (!row) {
-        throw new Error(`Unknown epic key: ${options.epicKey}`);
-      }
-      scope.epicId = row.id;
-    }
-    if (options.storyKey) {
-      const row = await this.db.get<{ id: string } | undefined>(
-        `SELECT id FROM user_stories WHERE key = ? ${scope.epicId ? "AND epic_id = ?" : ""}`,
-        scope.epicId ? [options.storyKey, scope.epicId] : [options.storyKey],
-      );
-      if (!row) {
-        throw new Error(`Unknown user story key: ${options.storyKey}`);
-      }
-      scope.storyId = row.id;
-    }
-    return scope;
-  }
-
-  private buildTaskFilters(scope: VelocityScopeIds, assignee?: string): { clause: string; params: any[] } {
-    const clauses: string[] = [];
-    const params: any[] = [];
-    if (scope.projectId) {
-      clauses.push("t.project_id = ?");
-      params.push(scope.projectId);
-    }
-    if (scope.epicId) {
-      clauses.push("t.epic_id = ?");
-      params.push(scope.epicId);
-    }
-    if (scope.storyId) {
-      clauses.push("t.user_story_id = ?");
-      params.push(scope.storyId);
-    }
-    if (assignee) {
-      clauses.push("LOWER(t.assignee_human) = LOWER(?)");
-      params.push(assignee);
-    }
-    if (clauses.length === 0) return { clause: "", params: [] };
-    return { clause: `AND ${clauses.join(" AND ")}`, params };
-  }
-
-  private async computeLaneVelocity(
-    commandName: string,
-    scope: VelocityScopeIds,
-    assignee: string | undefined,
-    windowTasks: number,
-  ): Promise<{ spPerHour?: number; samples: number }> {
-    const runs = await this.db.all<
-      { id: string; started_at?: string | null; completed_at?: string | null; duration_seconds?: number | null }[]
-    >(
-      `
-      SELECT id, started_at, completed_at, duration_seconds
-      FROM command_runs
-      WHERE command_name = ?
-        AND status IN ('success','succeeded')
-      ORDER BY COALESCE(completed_at, started_at) DESC
-    `,
-      commandName,
-    );
-
-    let totalSp = 0;
-    let totalDurationSeconds = 0;
-    let samples = 0;
-    const filters = this.buildTaskFilters(scope, assignee);
-
-    for (const run of runs) {
-      const aggregation = await this.db.get<{ sp: number | null; tasks: number }>(
-        `
-        SELECT
-          SUM(COALESCE(t.story_points, 0)) as sp,
-          COUNT(*) as tasks
-        FROM task_runs tr
-        INNER JOIN tasks t ON t.id = tr.task_id
-        WHERE tr.command_run_id = ?
-        ${filters.clause}
-      `,
-        run.id,
-        ...filters.params,
-      );
-
-      const taskCount = aggregation?.tasks ?? 0;
-      const sp = aggregation?.sp ?? 0;
-      if (taskCount === 0) {
-        continue;
-      }
-      const durationSeconds =
-        typeof run.duration_seconds === "number" && Number.isFinite(run.duration_seconds)
-          ? run.duration_seconds
-          : this.deriveDurationSeconds(run.started_at, run.completed_at);
-      if (!durationSeconds || durationSeconds <= 0) {
-        continue;
-      }
-      totalSp += sp;
-      totalDurationSeconds += durationSeconds;
-      samples += taskCount;
-      if (samples >= windowTasks) break;
-    }
-
-    if (samples === 0 || totalDurationSeconds <= 0 || totalSp <= 0) {
-      return { samples: 0 };
-    }
-
-    return {
-      spPerHour: totalSp / (totalDurationSeconds / 3600),
-      samples,
-    };
-  }
-
-  private deriveDurationSeconds(started?: string | null, completed?: string | null): number | undefined {
-    if (!started || !completed) return undefined;
-    const startMs = Date.parse(started);
-    const endMs = Date.parse(completed);
-    if (Number.isNaN(startMs) || Number.isNaN(endMs) || endMs <= startMs) return undefined;
-    return (endMs - startMs) / 1000;
-  }
-
-  async getEffectiveVelocity(options: VelocityOptions = {}): Promise<EffectiveVelocity> {
-    const mode = options.mode ?? "config";
-    const windowTasks = options.windowTasks ?? 10;
-    const config = this.resolveConfig(options);
-
-    if (mode === "config") {
-      return {
-        implementationSpPerHour: config.implementationSpPerHour,
-        reviewSpPerHour: config.reviewSpPerHour,
-        qaSpPerHour: config.qaSpPerHour,
-        source: "config",
-      };
-    }
-
-    const scope = await this.resolveScopeIds(options);
-    const implementation = await this.computeLaneVelocity("work-on-tasks", scope, options.assignee, windowTasks);
-    const review = await this.computeLaneVelocity("code-review", scope, options.assignee, windowTasks);
-    const qa = await this.computeLaneVelocity("qa-tasks", scope, options.assignee, windowTasks);
-
-    const alpha = config.alpha ?? DEFAULT_ALPHA;
-
-    const resolveLane = (empirical?: number): number => {
-      if (empirical === undefined || empirical <= 0) return config.implementationSpPerHour;
-      if (mode === "empirical") return empirical;
-      return alpha * empirical + (1 - alpha) * config.implementationSpPerHour;
-    };
-    const resolveReviewLane = (empirical?: number): number => {
-      if (empirical === undefined || empirical <= 0) return config.reviewSpPerHour;
-      if (mode === "empirical") return empirical;
-      return alpha * empirical + (1 - alpha) * config.reviewSpPerHour;
-    };
-    const resolveQaLane = (empirical?: number): number => {
-      if (empirical === undefined || empirical <= 0) return config.qaSpPerHour;
-      if (mode === "empirical") return empirical;
-      return alpha * empirical + (1 - alpha) * config.qaSpPerHour;
-    };
-
-    const implementationSpPerHour = resolveLane(implementation.spPerHour);
-    const reviewSpPerHour = resolveReviewLane(review.spPerHour);
-    const qaSpPerHour = resolveQaLane(qa.spPerHour);
-
-    const usedEmpirical =
-      (implementation.spPerHour && implementation.spPerHour > 0) ||
-      (review.spPerHour && review.spPerHour > 0) ||
-      (qa.spPerHour && qa.spPerHour > 0);
-
-    return {
-      implementationSpPerHour,
-      reviewSpPerHour,
-      qaSpPerHour,
-      source: usedEmpirical ? mode : "config",
-      windowTasks,
-      samples: {
-        implementation: implementation.samples,
-        review: review.samples,
-        qa: qa.samples,
-      },
-    };
-  }
-}

package/packages/core/src/services/estimate/__tests__/VelocityAndEstimate.test.ts

@@ -1,209 +0,0 @@
-import { strict as assert } from "node:assert";
-import os from "node:os";
-import path from "node:path";
-import fs from "node:fs/promises";
-import { test } from "node:test";
-import { WorkspaceRepository } from "@mcoda/db";
-import type { WorkspaceResolution } from "../../../workspace/WorkspaceManager.js";
-import { VelocityService } from "../VelocityService.js";
-import { EstimateService } from "../EstimateService.js";
-
-const createWorkspace = async () => {
-  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "mcoda-estimate-"));
-  const repo = await WorkspaceRepository.create(dir);
-  const workspace: WorkspaceResolution = {
-    workspaceRoot: dir,
-    workspaceId: dir,
-    mcodaDir: path.join(dir, ".mcoda"),
-    id: dir,
-    legacyWorkspaceIds: [],
-    workspaceDbPath: path.join(dir, ".mcoda", "mcoda.db"),
-    globalDbPath: path.join(os.homedir(), ".mcoda", "mcoda.db"),
-    config: {
-      velocity: {
-        implementationSpPerHour: 10,
-        reviewSpPerHour: 12,
-        qaSpPerHour: 8,
-        alpha: 0.5,
-      },
-    },
-  };
-  return { dir, repo, workspace };
-};
-
-test("VelocityService falls back to config when no history", async () => {
-  const { repo, workspace, dir } = await createWorkspace();
-  const velocityService = await VelocityService.create(workspace);
-  const velocity = await velocityService.getEffectiveVelocity({ mode: "empirical" });
-  assert.equal(velocity.source, "config");
-  assert.equal(velocity.implementationSpPerHour, 10);
-  assert.equal(velocity.reviewSpPerHour, 12);
-  assert.equal(velocity.qaSpPerHour, 8);
-  await velocityService.close();
-  await repo.close();
-  await fs.rm(dir, { recursive: true, force: true });
-});
-
-test("VelocityService computes empirical SP/hour per lane", async () => {
-  const { repo, workspace, dir } = await createWorkspace();
-  const project = await repo.createProjectIfMissing({ key: "PROJ" });
-  const [epic] = await repo.insertEpics(
-    [{ projectId: project.id, key: "E1", title: "Epic 1", description: "desc" }],
-    false,
-  );
-  const [story] = await repo.insertStories(
-    [
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        key: "S1",
-        title: "Story 1",
-        description: "desc",
-      },
-    ],
-    false,
-  );
-  const [taskA, taskB] = await repo.insertTasks(
-    [
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "T1",
-        title: "Task 1",
-        description: "desc",
-        status: "not_started",
-        storyPoints: 5,
-      },
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "T2",
-        title: "Task 2",
-        description: "desc",
-        status: "in_progress",
-        storyPoints: 3,
-      },
-    ],
-    false,
-  );
-
-  const startedAt = new Date().toISOString();
-  const completedAt = new Date(Date.parse(startedAt) + 3600 * 1000).toISOString();
-  const commandRun = await repo.createCommandRun({
-    workspaceId: workspace.workspaceId,
-    commandName: "work-on-tasks",
-    jobId: null,
-    taskIds: [taskA.id, taskB.id],
-    gitBranch: null,
-    gitBaseBranch: null,
-    startedAt,
-    status: "running",
-  });
-  await repo.completeCommandRun(commandRun.id, { status: "succeeded", completedAt, durationSeconds: 3600 });
-  await repo.createTaskRun({
-    taskId: taskA.id,
-    command: "work-on-tasks",
-    status: "succeeded",
-    commandRunId: commandRun.id,
-    startedAt,
-    finishedAt: completedAt,
-  });
-  await repo.createTaskRun({
-    taskId: taskB.id,
-    command: "work-on-tasks",
-    status: "succeeded",
-    commandRunId: commandRun.id,
-    startedAt,
-    finishedAt: completedAt,
-  });
-
-  const velocityService = await VelocityService.create(workspace);
-  const velocity = await velocityService.getEffectiveVelocity({
-    projectKey: project.key,
-    mode: "empirical",
-    windowTasks: 10,
-  });
-  assert.equal(Math.round((velocity.implementationSpPerHour ?? 0) * 100) / 100, 8);
-  assert.equal(velocity.source, "empirical");
-  await velocityService.close();
-  await repo.close();
-  await fs.rm(dir, { recursive: true, force: true });
-});
-
-test("EstimateService combines backlog totals and velocity", async () => {
-  const { repo, workspace, dir } = await createWorkspace();
-  const project = await repo.createProjectIfMissing({ key: "PROJ" });
-  const [epic] = await repo.insertEpics(
-    [{ projectId: project.id, key: "E1", title: "Epic 1", description: "desc" }],
-    false,
-  );
-  const [story] = await repo.insertStories(
-    [
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        key: "S1",
-        title: "Story 1",
-        description: "desc",
-      },
-    ],
-    false,
-  );
-
-  await repo.insertTasks(
-    [
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "T1",
-        title: "Task 1",
-        description: "desc",
-        status: "not_started",
-        storyPoints: 10,
-      },
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "T2",
-        title: "Task 2",
-        description: "desc",
-        status: "ready_to_review",
-        storyPoints: 4,
-      },
-      {
-        projectId: project.id,
-        epicId: epic.id,
-        userStoryId: story.id,
-        key: "T3",
-        title: "Task 3",
-        description: "desc",
-        status: "ready_to_qa",
-        storyPoints: 6,
-      },
-    ],
-    false,
-  );
-
-  const estimateService = await EstimateService.create(workspace);
-  const result = await estimateService.estimate({
-    projectKey: project.key,
-    mode: "config",
-    spPerHourAll: 10,
-  });
-
-  assert.equal(result.backlogTotals.implementation.story_points, 10);
-  assert.equal(result.backlogTotals.review.story_points, 4);
-  assert.equal(result.backlogTotals.qa.story_points, 6);
-  assert.equal(result.effectiveVelocity.source, "config");
-  assert.equal(result.durationsHours.implementationHours, 1);
-  assert.equal(result.durationsHours.reviewHours, 0.4);
-  assert.equal(result.durationsHours.qaHours, 0.6);
-  assert.ok(result.etas.completeEta);
-
-  await repo.close();
-  await fs.rm(dir, { recursive: true, force: true });
-});

package/packages/core/src/services/estimate/types.ts

@@ -1,41 +0,0 @@
-import type {
-  BacklogTotals,
-  EffectiveVelocity,
-  EstimateResult,
-  EstimateDurations,
-  EstimateEtas,
-  VelocitySource,
-} from "@mcoda/shared";
-import type { WorkspaceResolution } from "../../workspace/WorkspaceManager.js";
-
-export interface VelocityConfig {
-  implementationSpPerHour: number;
-  reviewSpPerHour: number;
-  qaSpPerHour: number;
-  alpha?: number;
-}
-
-export interface VelocityOptions {
-  projectKey?: string;
-  epicKey?: string;
-  storyKey?: string;
-  assignee?: string;
-  mode?: VelocitySource;
-  windowTasks?: 10 | 20 | 50;
-  spPerHourAll?: number;
-  spPerHourReview?: number;
-  spPerHourQa?: number;
-}
-
-export interface VelocityScopeIds {
-  projectId?: string;
-  epicId?: string;
-  storyId?: string;
-}
-
-export interface EstimateOptions extends VelocityOptions {
-  workspace: WorkspaceResolution;
-}
-
-export type { EstimateDurations, EstimateEtas };
-export type { EffectiveVelocity, EstimateResult, VelocitySource };

package/packages/core/src/services/execution/ExecutionService.ts

@@ -1 +0,0 @@
-export class ExecutionService {}