@uasyraf/helm 0.1.2 → 0.1.3

package/dashboard/build/server/chunks/db-GHaWnz-k.js

@@ -0,0 +1,806 @@
+import { createClient } from '@libsql/client';
+import { drizzle } from 'drizzle-orm/libsql';
+import { join } from 'node:path';
+import { homedir } from 'node:os';
+import { sqliteTable, text as text$1, integer as integer$1 } from 'drizzle-orm/sqlite-core';
+import { pgTable, text, integer, boolean } from 'drizzle-orm/pg-core';
+import { and, eq, desc, sql, isNull, ne } from 'drizzle-orm';
+
+const project$1 = sqliteTable("project", {
+  id: text$1("id").primaryKey(),
+  slug: text$1("slug").notNull().unique(),
+  name: text$1("name").notNull(),
+  gitRemote: text$1("git_remote"),
+  dod: text$1("dod"),
+  sprintLengthDays: integer$1("sprint_length_days").notNull().default(14),
+  wipEnabled: integer$1("wip_enabled", { mode: "boolean" }).notNull().default(false),
+  estimationEnabled: integer$1("estimation_enabled", { mode: "boolean" }).notNull().default(true),
+  createdAt: text$1("created_at").notNull()
+});
+const developer$1 = sqliteTable("developer", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  handle: text$1("handle").notNull(),
+  email: text$1("email"),
+  lastSeenAt: text$1("last_seen_at").notNull()
+});
+const sprint$1 = sqliteTable("sprint", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  name: text$1("name").notNull(),
+  goal: text$1("goal"),
+  startedAt: text$1("started_at").notNull(),
+  endedAt: text$1("ended_at"),
+  status: text$1("status").notNull(),
+  wipLimit: integer$1("wip_limit")
+});
+const epic$1 = sqliteTable("epic", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  title: text$1("title").notNull(),
+  description: text$1("description"),
+  status: text$1("status").notNull().default("open"),
+  priority: integer$1("priority").notNull().default(3),
+  targetSprintId: text$1("target_sprint_id").references(() => sprint$1.id),
+  createdAt: text$1("created_at").notNull()
+});
+const story$1 = sqliteTable("story", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  epicId: text$1("epic_id").references(() => epic$1.id),
+  sprintId: text$1("sprint_id").references(() => sprint$1.id),
+  title: text$1("title").notNull(),
+  description: text$1("description"),
+  acceptance: text$1("acceptance"),
+  status: text$1("status").notNull().default("backlog"),
+  size: text$1("size"),
+  assigneeId: text$1("assignee_id").references(() => developer$1.id),
+  priority: integer$1("priority").notNull().default(3),
+  startedAt: text$1("started_at"),
+  completedAt: text$1("completed_at"),
+  createdAt: text$1("created_at").notNull()
+});
+const task$1 = sqliteTable("task", {
+  id: text$1("id").primaryKey(),
+  storyId: text$1("story_id").notNull().references(() => story$1.id),
+  assigneeId: text$1("assignee_id").references(() => developer$1.id),
+  title: text$1("title").notNull(),
+  status: text$1("status").notNull().default("todo"),
+  blockedBy: text$1("blocked_by"),
+  createdAt: text$1("created_at").notNull()
+});
+const techDebt$1 = sqliteTable("tech_debt", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  title: text$1("title").notNull(),
+  description: text$1("description"),
+  severity: text$1("severity").notNull().default("med"),
+  location: text$1("location"),
+  ownerId: text$1("owner_id").references(() => developer$1.id),
+  expiresAt: text$1("expires_at"),
+  openedAt: text$1("opened_at").notNull(),
+  closedAt: text$1("closed_at"),
+  linkedStoryId: text$1("linked_story_id").references(() => story$1.id)
+});
+const decision$1 = sqliteTable("decision", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  title: text$1("title").notNull(),
+  context: text$1("context"),
+  decision: text$1("decision").notNull(),
+  status: text$1("status").notNull().default("accepted"),
+  decidedAt: text$1("decided_at").notNull()
+});
+const progressEvent$1 = sqliteTable("progress_event", {
+  id: text$1("id").primaryKey(),
+  projectId: text$1("project_id").notNull().references(() => project$1.id),
+  developerId: text$1("developer_id").references(() => developer$1.id),
+  sprintId: text$1("sprint_id").references(() => sprint$1.id),
+  kind: text$1("kind").notNull(),
+  refId: text$1("ref_id"),
+  summary: text$1("summary").notNull(),
+  ts: text$1("ts").notNull()
+});
+const schema$1 = {
+  project: project$1,
+  developer: developer$1,
+  sprint: sprint$1,
+  epic: epic$1,
+  story: story$1,
+  task: task$1,
+  techDebt: techDebt$1,
+  decision: decision$1,
+  progressEvent: progressEvent$1
+};
+const project = pgTable("project", {
+  id: text("id").primaryKey(),
+  slug: text("slug").notNull().unique(),
+  name: text("name").notNull(),
+  gitRemote: text("git_remote"),
+  dod: text("dod"),
+  sprintLengthDays: integer("sprint_length_days").notNull().default(14),
+  wipEnabled: boolean("wip_enabled").notNull().default(false),
+  estimationEnabled: boolean("estimation_enabled").notNull().default(true),
+  createdAt: text("created_at").notNull()
+});
+const developer = pgTable("developer", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  handle: text("handle").notNull(),
+  email: text("email"),
+  lastSeenAt: text("last_seen_at").notNull()
+});
+const sprint = pgTable("sprint", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  name: text("name").notNull(),
+  goal: text("goal"),
+  startedAt: text("started_at").notNull(),
+  endedAt: text("ended_at"),
+  status: text("status").notNull(),
+  wipLimit: integer("wip_limit")
+});
+const epic = pgTable("epic", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  title: text("title").notNull(),
+  description: text("description"),
+  status: text("status").notNull().default("open"),
+  priority: integer("priority").notNull().default(3),
+  targetSprintId: text("target_sprint_id").references(() => sprint.id),
+  createdAt: text("created_at").notNull()
+});
+const story = pgTable("story", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  epicId: text("epic_id").references(() => epic.id),
+  sprintId: text("sprint_id").references(() => sprint.id),
+  title: text("title").notNull(),
+  description: text("description"),
+  acceptance: text("acceptance"),
+  status: text("status").notNull().default("backlog"),
+  size: text("size"),
+  assigneeId: text("assignee_id").references(() => developer.id),
+  priority: integer("priority").notNull().default(3),
+  startedAt: text("started_at"),
+  completedAt: text("completed_at"),
+  createdAt: text("created_at").notNull()
+});
+const task = pgTable("task", {
+  id: text("id").primaryKey(),
+  storyId: text("story_id").notNull().references(() => story.id),
+  assigneeId: text("assignee_id").references(() => developer.id),
+  title: text("title").notNull(),
+  status: text("status").notNull().default("todo"),
+  blockedBy: text("blocked_by"),
+  createdAt: text("created_at").notNull()
+});
+const techDebt = pgTable("tech_debt", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  title: text("title").notNull(),
+  description: text("description"),
+  severity: text("severity").notNull().default("med"),
+  location: text("location"),
+  ownerId: text("owner_id").references(() => developer.id),
+  expiresAt: text("expires_at"),
+  openedAt: text("opened_at").notNull(),
+  closedAt: text("closed_at"),
+  linkedStoryId: text("linked_story_id").references(() => story.id)
+});
+const decision = pgTable("decision", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  title: text("title").notNull(),
+  context: text("context"),
+  decision: text("decision").notNull(),
+  status: text("status").notNull().default("accepted"),
+  decidedAt: text("decided_at").notNull()
+});
+const progressEvent = pgTable("progress_event", {
+  id: text("id").primaryKey(),
+  projectId: text("project_id").notNull().references(() => project.id),
+  developerId: text("developer_id").references(() => developer.id),
+  sprintId: text("sprint_id").references(() => sprint.id),
+  kind: text("kind").notNull(),
+  refId: text("ref_id"),
+  summary: text("summary").notNull(),
+  ts: text("ts").notNull()
+});
+const schema = {
+  project,
+  developer,
+  sprint,
+  epic,
+  story,
+  task,
+  techDebt,
+  decision,
+  progressEvent
+};
+function makeSqliteRepo(db) {
+  return {
+    async findProjectBySlug(slug) {
+      const rows = await db.select().from(project$1).where(eq(project$1.slug, slug)).limit(1);
+      return rows[0] ?? null;
+    },
+    async findAllProjects() {
+      return db.select().from(project$1).orderBy(project$1.name);
+    },
+    async insertProject(row) {
+      await db.insert(project$1).values(row);
+    },
+    async findDeveloperByHandle(projectId, handle) {
+      const rows = await db.select().from(developer$1).where(and(eq(developer$1.projectId, projectId), eq(developer$1.handle, handle))).limit(1);
+      return rows[0] ?? null;
+    },
+    async insertDeveloper(row) {
+      await db.insert(developer$1).values(row);
+    },
+    async touchDeveloper(id, lastSeenAt) {
+      await db.update(developer$1).set({ lastSeenAt }).where(eq(developer$1.id, id));
+    },
+    async findDevelopersByProject(projectId) {
+      return db.select().from(developer$1).where(eq(developer$1.projectId, projectId)).orderBy(desc(developer$1.lastSeenAt));
+    },
+    async findActiveSprint(projectId) {
+      const rows = await db.select().from(sprint$1).where(and(eq(sprint$1.projectId, projectId), eq(sprint$1.status, "active"))).limit(1);
+      return rows[0] ?? null;
+    },
+    async findSprintById(id) {
+      const rows = await db.select().from(sprint$1).where(eq(sprint$1.id, id)).limit(1);
+      return rows[0] ?? null;
+    },
+    async findSprintsByProject(projectId) {
+      return db.select().from(sprint$1).where(eq(sprint$1.projectId, projectId)).orderBy(desc(sprint$1.startedAt));
+    },
+    async insertSprint(row) {
+      await db.insert(sprint$1).values(row);
+    },
+    async updateSprint(id, updates) {
+      await db.update(sprint$1).set(updates).where(eq(sprint$1.id, id));
+    },
+    async closeActiveSprints(projectId, endedAt) {
+      await db.update(sprint$1).set({ status: "closed", endedAt }).where(and(eq(sprint$1.projectId, projectId), eq(sprint$1.status, "active")));
+    },
+    async countSprintsByProject(projectId) {
+      const rows = await db.select({ c: sql`count(*)` }).from(sprint$1).where(eq(sprint$1.projectId, projectId));
+      return rows[0]?.c ?? 0;
+    },
+    async insertEpic(row) {
+      await db.insert(epic$1).values(row);
+    },
+    async updateEpic(id, updates) {
+      await db.update(epic$1).set(updates).where(eq(epic$1.id, id));
+    },
+    async findEpicsByProject(projectId) {
+      return db.select().from(epic$1).where(eq(epic$1.projectId, projectId)).orderBy(epic$1.priority);
+    },
+    async insertStory(row) {
+      await db.insert(story$1).values(row);
+    },
+    async updateStory(id, updates) {
+      await db.update(story$1).set(updates).where(eq(story$1.id, id));
+    },
+    async findStoryById(id) {
+      const rows = await db.select().from(story$1).where(eq(story$1.id, id)).limit(1);
+      return rows[0] ?? null;
+    },
+    async findStoriesInSprint(sprintId) {
+      return db.select().from(story$1).where(eq(story$1.sprintId, sprintId)).orderBy(story$1.priority);
+    },
+    async findStoriesInSprintNotDoneOrDropped(sprintId) {
+      return db.select().from(story$1).where(and(eq(story$1.sprintId, sprintId), ne(story$1.status, "done"), ne(story$1.status, "dropped")));
+    },
+    async rolloverIncompleteStoriesToBacklog(sprintId) {
+      const incomplete = await db.select({ id: story$1.id }).from(story$1).where(and(eq(story$1.sprintId, sprintId), ne(story$1.status, "done"), ne(story$1.status, "dropped")));
+      if (incomplete.length === 0) return 0;
+      await db.update(story$1).set({ sprintId: null, status: "backlog" }).where(and(eq(story$1.sprintId, sprintId), ne(story$1.status, "done"), ne(story$1.status, "dropped")));
+      return incomplete.length;
+    },
+    async findBacklogStories(projectId, limit) {
+      return db.select().from(story$1).where(and(eq(story$1.projectId, projectId), isNull(story$1.sprintId), eq(story$1.status, "backlog"))).orderBy(sql`priority asc, created_at asc`).limit(limit);
+    },
+    async countStoriesInSprintByStatus(sprintId) {
+      const rows = await db.select({ status: story$1.status, count: sql`count(*)` }).from(story$1).where(eq(story$1.sprintId, sprintId)).groupBy(story$1.status);
+      const out = {};
+      for (const r of rows) out[r.status] = r.count;
+      return out;
+    },
+    async countBacklog(projectId) {
+      const rows = await db.select({ c: sql`count(*)` }).from(story$1).where(and(eq(story$1.projectId, projectId), eq(story$1.status, "backlog"), isNull(story$1.sprintId)));
+      return rows[0]?.c ?? 0;
+    },
+    async countDoneStoriesInSprint(sprintId) {
+      const rows = await db.select({ c: sql`count(*)` }).from(story$1).where(and(eq(story$1.sprintId, sprintId), eq(story$1.status, "done")));
+      return rows[0]?.c ?? 0;
+    },
+    async insertTask(row) {
+      await db.insert(task$1).values(row);
+    },
+    async updateTask(id, updates) {
+      await db.update(task$1).set(updates).where(eq(task$1.id, id));
+    },
+    async insertDebt(row) {
+      await db.insert(techDebt$1).values(row);
+    },
+    async closeDebt(id, closedAt) {
+      await db.update(techDebt$1).set({ closedAt }).where(eq(techDebt$1.id, id));
+    },
+    async findOpenDebtByProject(projectId, limit) {
+      return db.select().from(techDebt$1).where(and(eq(techDebt$1.projectId, projectId), isNull(techDebt$1.closedAt))).orderBy(sql`severity desc, opened_at desc`).limit(limit);
+    },
+    async findAllDebtByProject(projectId, limit) {
+      return db.select().from(techDebt$1).where(eq(techDebt$1.projectId, projectId)).orderBy(sql`closed_at is null desc, severity desc, opened_at desc`).limit(limit);
+    },
+    async findOpenDebtAtLocation(projectId, location) {
+      const rows = await db.select().from(techDebt$1).where(and(eq(techDebt$1.projectId, projectId), eq(techDebt$1.location, location), isNull(techDebt$1.closedAt))).limit(1);
+      return rows[0] ?? null;
+    },
+    async countOpenDebtByProject(projectId) {
+      const rows = await db.select({ c: sql`count(*)` }).from(techDebt$1).where(and(eq(techDebt$1.projectId, projectId), isNull(techDebt$1.closedAt)));
+      return rows[0]?.c ?? 0;
+    },
+    async insertDecision(row) {
+      await db.insert(decision$1).values(row);
+    },
+    async findDecisionsByProject(projectId, limit) {
+      return db.select().from(decision$1).where(eq(decision$1.projectId, projectId)).orderBy(desc(decision$1.decidedAt)).limit(limit);
+    },
+    async emitEvent(row) {
+      await db.insert(progressEvent$1).values(row);
+    },
+    async findRecentEvents(projectId, limit) {
+      return db.select().from(progressEvent$1).where(eq(progressEvent$1.projectId, projectId)).orderBy(desc(progressEvent$1.ts)).limit(limit);
+    },
+    async findEventsForSprint(sprintId, limit) {
+      return db.select().from(progressEvent$1).where(eq(progressEvent$1.sprintId, sprintId)).orderBy(desc(progressEvent$1.ts)).limit(limit);
+    },
+    async countEventsByKindInSprint(sprintId, kind) {
+      const rows = await db.select({ c: sql`count(*)` }).from(progressEvent$1).where(and(eq(progressEvent$1.sprintId, sprintId), eq(progressEvent$1.kind, kind)));
+      return rows[0]?.c ?? 0;
+    },
+    async findEventsByDeveloper(projectId, developerId, limit) {
+      return db.select().from(progressEvent$1).where(and(eq(progressEvent$1.projectId, projectId), eq(progressEvent$1.developerId, developerId))).orderBy(desc(progressEvent$1.ts)).limit(limit);
+    }
+  };
+}
+function makePgRepo(db) {
+  const pg = db;
+  return {
+    async findProjectBySlug(slug) {
+      const rows = await pg.select().from(project).where(eq(project.slug, slug)).limit(1);
+      return rows[0] ?? null;
+    },
+    async findAllProjects() {
+      const rows = await pg.select().from(project).orderBy(project.name);
+      return rows;
+    },
+    async insertProject(row) {
+      await pg.insert(project).values(row);
+    },
+    async findDeveloperByHandle(projectId, handle) {
+      const rows = await pg.select().from(developer).where(and(eq(developer.projectId, projectId), eq(developer.handle, handle))).limit(1);
+      return rows[0] ?? null;
+    },
+    async insertDeveloper(row) {
+      await pg.insert(developer).values(row);
+    },
+    async touchDeveloper(id, lastSeenAt) {
+      await pg.update(developer).set({ lastSeenAt }).where(eq(developer.id, id));
+    },
+    async findDevelopersByProject(projectId) {
+      const rows = await pg.select().from(developer).where(eq(developer.projectId, projectId)).orderBy(desc(developer.lastSeenAt));
+      return rows;
+    },
+    async findActiveSprint(projectId) {
+      const rows = await pg.select().from(sprint).where(and(eq(sprint.projectId, projectId), eq(sprint.status, "active"))).limit(1);
+      return rows[0] ?? null;
+    },
+    async findSprintById(id) {
+      const rows = await pg.select().from(sprint).where(eq(sprint.id, id)).limit(1);
+      return rows[0] ?? null;
+    },
+    async findSprintsByProject(projectId) {
+      const rows = await pg.select().from(sprint).where(eq(sprint.projectId, projectId)).orderBy(desc(sprint.startedAt));
+      return rows;
+    },
+    async insertSprint(row) {
+      await pg.insert(sprint).values(row);
+    },
+    async updateSprint(id, updates) {
+      await pg.update(sprint).set(updates).where(eq(sprint.id, id));
+    },
+    async closeActiveSprints(projectId, endedAt) {
+      await pg.update(sprint).set({ status: "closed", endedAt }).where(and(eq(sprint.projectId, projectId), eq(sprint.status, "active")));
+    },
+    async countSprintsByProject(projectId) {
+      const rows = await pg.select({ c: sql`count(*)::int` }).from(sprint).where(eq(sprint.projectId, projectId));
+      return Number(rows[0]?.c ?? 0);
+    },
+    async insertEpic(row) {
+      await pg.insert(epic).values(row);
+    },
+    async updateEpic(id, updates) {
+      await pg.update(epic).set(updates).where(eq(epic.id, id));
+    },
+    async findEpicsByProject(projectId) {
+      const rows = await pg.select().from(epic).where(eq(epic.projectId, projectId)).orderBy(epic.priority);
+      return rows;
+    },
+    async insertStory(row) {
+      await pg.insert(story).values(row);
+    },
+    async updateStory(id, updates) {
+      await pg.update(story).set(updates).where(eq(story.id, id));
+    },
+    async findStoryById(id) {
+      const rows = await pg.select().from(story).where(eq(story.id, id)).limit(1);
+      return rows[0] ?? null;
+    },
+    async findStoriesInSprint(sprintId) {
+      const rows = await pg.select().from(story).where(eq(story.sprintId, sprintId)).orderBy(story.priority);
+      return rows;
+    },
+    async findStoriesInSprintNotDoneOrDropped(sprintId) {
+      const rows = await pg.select().from(story).where(and(eq(story.sprintId, sprintId), ne(story.status, "done"), ne(story.status, "dropped")));
+      return rows;
+    },
+    async rolloverIncompleteStoriesToBacklog(sprintId) {
+      const incomplete = await pg.select({ id: story.id }).from(story).where(and(eq(story.sprintId, sprintId), ne(story.status, "done"), ne(story.status, "dropped")));
+      if (incomplete.length === 0) return 0;
+      await pg.update(story).set({ sprintId: null, status: "backlog" }).where(and(eq(story.sprintId, sprintId), ne(story.status, "done"), ne(story.status, "dropped")));
+      return incomplete.length;
+    },
+    async findBacklogStories(projectId, limit) {
+      const rows = await pg.select().from(story).where(and(eq(story.projectId, projectId), isNull(story.sprintId), eq(story.status, "backlog"))).orderBy(sql`priority asc, created_at asc`).limit(limit);
+      return rows;
+    },
+    async countStoriesInSprintByStatus(sprintId) {
+      const rows = await pg.select({ status: story.status, count: sql`count(*)::int` }).from(story).where(eq(story.sprintId, sprintId)).groupBy(story.status);
+      const out = {};
+      for (const r of rows) out[r.status] = Number(r.count);
+      return out;
+    },
+    async countBacklog(projectId) {
+      const rows = await pg.select({ c: sql`count(*)::int` }).from(story).where(and(eq(story.projectId, projectId), eq(story.status, "backlog"), isNull(story.sprintId)));
+      return Number(rows[0]?.c ?? 0);
+    },
+    async countDoneStoriesInSprint(sprintId) {
+      const rows = await pg.select({ c: sql`count(*)::int` }).from(story).where(and(eq(story.sprintId, sprintId), eq(story.status, "done")));
+      return Number(rows[0]?.c ?? 0);
+    },
+    async insertTask(row) {
+      await pg.insert(task).values(row);
+    },
+    async updateTask(id, updates) {
+      await pg.update(task).set(updates).where(eq(task.id, id));
+    },
+    async insertDebt(row) {
+      await pg.insert(techDebt).values(row);
+    },
+    async closeDebt(id, closedAt) {
+      await pg.update(techDebt).set({ closedAt }).where(eq(techDebt.id, id));
+    },
+    async findOpenDebtByProject(projectId, limit) {
+      const rows = await pg.select().from(techDebt).where(and(eq(techDebt.projectId, projectId), isNull(techDebt.closedAt))).orderBy(sql`severity desc, opened_at desc`).limit(limit);
+      return rows;
+    },
+    async findAllDebtByProject(projectId, limit) {
+      const rows = await pg.select().from(techDebt).where(eq(techDebt.projectId, projectId)).orderBy(sql`closed_at is null desc, severity desc, opened_at desc`).limit(limit);
+      return rows;
+    },
+    async findOpenDebtAtLocation(projectId, location) {
+      const rows = await pg.select().from(techDebt).where(and(eq(techDebt.projectId, projectId), eq(techDebt.location, location), isNull(techDebt.closedAt))).limit(1);
+      return rows[0] ?? null;
+    },
+    async countOpenDebtByProject(projectId) {
+      const rows = await pg.select({ c: sql`count(*)::int` }).from(techDebt).where(and(eq(techDebt.projectId, projectId), isNull(techDebt.closedAt)));
+      return Number(rows[0]?.c ?? 0);
+    },
+    async insertDecision(row) {
+      await pg.insert(decision).values(row);
+    },
+    async findDecisionsByProject(projectId, limit) {
+      const rows = await pg.select().from(decision).where(eq(decision.projectId, projectId)).orderBy(desc(decision.decidedAt)).limit(limit);
+      return rows;
+    },
+    async emitEvent(row) {
+      await pg.insert(progressEvent).values(row);
+    },
+    async findRecentEvents(projectId, limit) {
+      const rows = await pg.select().from(progressEvent).where(eq(progressEvent.projectId, projectId)).orderBy(desc(progressEvent.ts)).limit(limit);
+      return rows;
+    },
+    async findEventsForSprint(sprintId, limit) {
+      const rows = await pg.select().from(progressEvent).where(eq(progressEvent.sprintId, sprintId)).orderBy(desc(progressEvent.ts)).limit(limit);
+      return rows;
+    },
+    async countEventsByKindInSprint(sprintId, kind) {
+      const rows = await pg.select({ c: sql`count(*)::int` }).from(progressEvent).where(and(eq(progressEvent.sprintId, sprintId), eq(progressEvent.kind, kind)));
+      return Number(rows[0]?.c ?? 0);
+    },
+    async findEventsByDeveloper(projectId, developerId, limit) {
+      const rows = await pg.select().from(progressEvent).where(and(eq(progressEvent.projectId, projectId), eq(progressEvent.developerId, developerId))).orderBy(desc(progressEvent.ts)).limit(limit);
+      return rows;
+    }
+  };
+}
+const STATEMENTS$1 = [
+  `CREATE TABLE IF NOT EXISTS project (
+    id TEXT PRIMARY KEY,
+    slug TEXT NOT NULL UNIQUE,
+    name TEXT NOT NULL,
+    git_remote TEXT,
+    dod TEXT,
+    sprint_length_days INTEGER NOT NULL DEFAULT 14,
+    wip_enabled INTEGER NOT NULL DEFAULT 0,
+    estimation_enabled INTEGER NOT NULL DEFAULT 1,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS developer (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    handle TEXT NOT NULL,
+    email TEXT,
+    last_seen_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS sprint (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    name TEXT NOT NULL,
+    goal TEXT,
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    status TEXT NOT NULL,
+    wip_limit INTEGER
+  )`,
+  `CREATE TABLE IF NOT EXISTS epic (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'open',
+    priority INTEGER NOT NULL DEFAULT 3,
+    target_sprint_id TEXT REFERENCES sprint(id),
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS story (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    epic_id TEXT REFERENCES epic(id),
+    sprint_id TEXT REFERENCES sprint(id),
+    title TEXT NOT NULL,
+    description TEXT,
+    acceptance TEXT,
+    status TEXT NOT NULL DEFAULT 'backlog',
+    size TEXT,
+    assignee_id TEXT REFERENCES developer(id),
+    priority INTEGER NOT NULL DEFAULT 3,
+    started_at TEXT,
+    completed_at TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS task (
+    id TEXT PRIMARY KEY,
+    story_id TEXT NOT NULL REFERENCES story(id),
+    assignee_id TEXT REFERENCES developer(id),
+    title TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'todo',
+    blocked_by TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS tech_debt (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    title TEXT NOT NULL,
+    description TEXT,
+    severity TEXT NOT NULL DEFAULT 'med',
+    location TEXT,
+    owner_id TEXT REFERENCES developer(id),
+    expires_at TEXT,
+    opened_at TEXT NOT NULL,
+    closed_at TEXT,
+    linked_story_id TEXT REFERENCES story(id)
+  )`,
+  `CREATE TABLE IF NOT EXISTS decision (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    title TEXT NOT NULL,
+    context TEXT,
+    decision TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'accepted',
+    decided_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS progress_event (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    developer_id TEXT REFERENCES developer(id),
+    sprint_id TEXT REFERENCES sprint(id),
+    kind TEXT NOT NULL,
+    ref_id TEXT,
+    summary TEXT NOT NULL,
+    ts TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_progress_event_ts ON progress_event(ts DESC)`,
+  `CREATE INDEX IF NOT EXISTS idx_story_sprint ON story(sprint_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_story_status ON story(status)`,
+  `CREATE INDEX IF NOT EXISTS idx_story_project ON story(project_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_tech_debt_closed ON tech_debt(closed_at)`
+];
+async function ensureStoryProjectColumn(client) {
+  const info = await client.execute("PRAGMA table_info(story)");
+  const hasProject = info.rows.some((r) => String(r.name) === "project_id");
+  if (hasProject) return;
+  await client.execute("ALTER TABLE story ADD COLUMN project_id TEXT REFERENCES project(id)");
+  await client.execute(`
+    UPDATE story SET project_id = COALESCE(
+      (SELECT s.project_id FROM sprint s WHERE s.id = story.sprint_id),
+      (SELECT e.project_id FROM epic e WHERE e.id = story.epic_id),
+      (SELECT p.id FROM project p ORDER BY p.created_at LIMIT 1)
+    )
+    WHERE project_id IS NULL
+  `);
+  await client.execute("CREATE INDEX IF NOT EXISTS idx_story_project ON story(project_id)");
+}
+async function bootstrap(client) {
+  for (const sql2 of STATEMENTS$1) {
+    await client.execute(sql2);
+  }
+  await ensureStoryProjectColumn(client);
+}
+const STATEMENTS = [
+  `CREATE TABLE IF NOT EXISTS project (
+    id TEXT PRIMARY KEY,
+    slug TEXT NOT NULL UNIQUE,
+    name TEXT NOT NULL,
+    git_remote TEXT,
+    dod TEXT,
+    sprint_length_days INTEGER NOT NULL DEFAULT 14,
+    wip_enabled BOOLEAN NOT NULL DEFAULT FALSE,
+    estimation_enabled BOOLEAN NOT NULL DEFAULT TRUE,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS developer (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    handle TEXT NOT NULL,
+    email TEXT,
+    last_seen_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS sprint (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    name TEXT NOT NULL,
+    goal TEXT,
+    started_at TEXT NOT NULL,
+    ended_at TEXT,
+    status TEXT NOT NULL,
+    wip_limit INTEGER
+  )`,
+  `CREATE TABLE IF NOT EXISTS epic (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    title TEXT NOT NULL,
+    description TEXT,
+    status TEXT NOT NULL DEFAULT 'open',
+    priority INTEGER NOT NULL DEFAULT 3,
+    target_sprint_id TEXT REFERENCES sprint(id),
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS story (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    epic_id TEXT REFERENCES epic(id),
+    sprint_id TEXT REFERENCES sprint(id),
+    title TEXT NOT NULL,
+    description TEXT,
+    acceptance TEXT,
+    status TEXT NOT NULL DEFAULT 'backlog',
+    size TEXT,
+    assignee_id TEXT REFERENCES developer(id),
+    priority INTEGER NOT NULL DEFAULT 3,
+    started_at TEXT,
+    completed_at TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS task (
+    id TEXT PRIMARY KEY,
+    story_id TEXT NOT NULL REFERENCES story(id),
+    assignee_id TEXT REFERENCES developer(id),
+    title TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'todo',
+    blocked_by TEXT,
+    created_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS tech_debt (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    title TEXT NOT NULL,
+    description TEXT,
+    severity TEXT NOT NULL DEFAULT 'med',
+    location TEXT,
+    owner_id TEXT REFERENCES developer(id),
+    expires_at TEXT,
+    opened_at TEXT NOT NULL,
+    closed_at TEXT,
+    linked_story_id TEXT REFERENCES story(id)
+  )`,
+  `CREATE TABLE IF NOT EXISTS decision (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    title TEXT NOT NULL,
+    context TEXT,
+    decision TEXT NOT NULL,
+    status TEXT NOT NULL DEFAULT 'accepted',
+    decided_at TEXT NOT NULL
+  )`,
+  `CREATE TABLE IF NOT EXISTS progress_event (
+    id TEXT PRIMARY KEY,
+    project_id TEXT NOT NULL REFERENCES project(id),
+    developer_id TEXT REFERENCES developer(id),
+    sprint_id TEXT REFERENCES sprint(id),
+    kind TEXT NOT NULL,
+    ref_id TEXT,
+    summary TEXT NOT NULL,
+    ts TEXT NOT NULL
+  )`,
+  `CREATE INDEX IF NOT EXISTS idx_progress_event_ts ON progress_event(ts DESC)`,
+  `CREATE INDEX IF NOT EXISTS idx_story_sprint ON story(sprint_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_story_status ON story(status)`,
+  `CREATE INDEX IF NOT EXISTS idx_story_project ON story(project_id)`,
+  `CREATE INDEX IF NOT EXISTS idx_tech_debt_closed ON tech_debt(closed_at)`
+];
+const MIGRATIONS = [
+  `ALTER TABLE story ADD COLUMN IF NOT EXISTS project_id TEXT REFERENCES project(id)`,
+  `UPDATE story SET project_id = COALESCE(
+     (SELECT s.project_id FROM sprint s WHERE s.id = story.sprint_id),
+     (SELECT e.project_id FROM epic e WHERE e.id = story.epic_id),
+     (SELECT p.id FROM project p ORDER BY p.created_at LIMIT 1)
+   )
+   WHERE project_id IS NULL`
+];
+async function bootstrapPg(runner) {
+  for (const sql2 of STATEMENTS) {
+    await runner.query(sql2);
+  }
+  for (const sql2 of MIGRATIONS) {
+    await runner.query(sql2);
+  }
+}
+let cached = null;
+function helmHome() {
+  return process.env.HELM_HOME ?? join(homedir(), ".helm");
+}
+function unifiedDbPath() {
+  return process.env.HELM_DB_PATH ?? join(helmHome(), "helm.db");
+}
+function defaultSlug() {
+  return process.env.HELM_PROJECT_SLUG ?? null;
+}
+async function repo() {
+  if (cached) return cached;
+  const dbUrl = process.env.HELM_DB_URL ?? "";
+  if (dbUrl.startsWith("postgres://") || dbUrl.startsWith("postgresql://")) {
+    const [{ Pool }, { drizzle: drizzle2 }] = await Promise.all([
+      import('pg'),
+      import('drizzle-orm/node-postgres')
+    ]);
+    const pool = new Pool({ connectionString: dbUrl });
+    await bootstrapPg({ query: async (sql2) => {
+      await pool.query(sql2);
+    } });
+    const pg = drizzle2(pool, { schema });
+    cached = makePgRepo(pg);
+    return cached;
+  }
+  const path = unifiedDbPath();
+  const client = createClient({ url: `file:${path}` });
+  await bootstrap(client);
+  const drizzled = drizzle(client, { schema: schema$1 });
+  cached = makeSqliteRepo(drizzled);
+  return cached;
+}
+
+export { defaultSlug as d, repo as r };
+//# sourceMappingURL=db-GHaWnz-k.js.map