@yattalo/task-system 0.4.0 → 0.5.0

package/templates/uca/ucaTasks.ts

@@ -0,0 +1,500 @@
+// ============================================================
+// UCA Tasks — Full task CRUD with commit tracking & audit trail
+// Generated by @yattalo/task-system — matches dashboard SPA API surface
+// ============================================================
+
+import { mutation, query } from "../_generated/server";
+import { v } from "convex/values";
+
+function makeId(prefix: string): string {
+  return `${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+
+function extractHashFromDescription(description?: string): string | undefined {
+  if (!description) return undefined;
+  const commitMatch = description.match(/\bcommit\s+([0-9a-f]{7,40})\b/i);
+  if (commitMatch?.[1]) return commitMatch[1].toLowerCase();
+  const trailerMatch = description.match(/\btask-done:\s*([0-9a-f]{7,40})\b/i);
+  if (trailerMatch?.[1]) return trailerMatch[1].toLowerCase();
+  return undefined;
+}
+
+function inferCommitHash(task: any, note?: string, explicit?: string): string | undefined {
+  if (explicit) return explicit.toLowerCase();
+  const fromNote = extractHashFromDescription(note);
+  if (fromNote) return fromNote;
+  const fromDescription = extractHashFromDescription(task.description);
+  if (fromDescription) return fromDescription;
+  const commits = Array.isArray(task.commits) ? task.commits : [];
+  if (commits.length > 0) {
+    const latest = [...commits].sort((a, b) => b.timestamp - a.timestamp)[0];
+    if (latest?.hash) return latest.hash.toLowerCase();
+  }
+  return undefined;
+}
+
+async function findTaskByTaskId(ctx: any, taskId: string): Promise<any | null> {
+  return await ctx.db.query("tasks").withIndex("by_taskId", (q: any) => q.eq("taskId", taskId)).first();
+}
+
+async function resolveTask(ctx: any, locator: { id?: any; taskId?: string }): Promise<any> {
+  if (locator.id) {
+    const task = await ctx.db.get(locator.id);
+    if (!task) throw new Error("Task not found");
+    return task;
+  }
+  if (locator.taskId) {
+    const task = await findTaskByTaskId(ctx, locator.taskId);
+    if (!task) throw new Error(`Task ${locator.taskId} not found`);
+    return task;
+  }
+  throw new Error("Either id or taskId must be provided");
+}
+
+async function insertCommitCaptureIfMissing(ctx: any, args: {
+  taskId: string;
+  hash: string;
+  message: string;
+  source: "status_done" | "hook" | "manual" | "backfill";
+  filesChanged?: string[];
+  capturedBy?: string;
+  capturedAt?: number;
+}): Promise<void> {
+  const existing = await ctx.db
+    .query("commitCaptures")
+    .withIndex("by_taskId", (q: any) => q.eq("taskId", args.taskId))
+    .collect();
+  const duplicate = existing.some((capture: any) => capture.commitHash === args.hash);
+  if (duplicate) return;
+  await ctx.db.insert("commitCaptures", {
+    captureId: makeId("capture"),
+    taskId: args.taskId,
+    commitHash: args.hash,
+    message: args.message,
+    source: args.source,
+    filesChanged: args.filesChanged,
+    capturedBy: args.capturedBy,
+    capturedAt: args.capturedAt ?? Date.now(),
+  });
+}
+
+async function resolvePendingCommitRequests(ctx: any, taskId: string): Promise<number> {
+  const pending = await ctx.db
+    .query("pendingCommitCaptures")
+    .withIndex("by_taskId", (q: any) => q.eq("taskId", taskId))
+    .collect();
+  const unresolved = pending.filter((entry: any) => entry.status === "pending");
+  for (const entry of unresolved) {
+    await ctx.db.patch(entry._id, { status: "resolved", resolvedAt: Date.now() });
+  }
+  return unresolved.length;
+}
+
+async function ensurePendingCommitRequest(ctx: any, taskId: string, note?: string): Promise<void> {
+  const pending = await ctx.db
+    .query("pendingCommitCaptures")
+    .withIndex("by_taskId", (q: any) => q.eq("taskId", taskId))
+    .collect();
+  const unresolved = pending.find((entry: any) => entry.status === "pending");
+  if (unresolved) return;
+  await ctx.db.insert("pendingCommitCaptures", {
+    requestId: makeId("pcc"),
+    taskId,
+    status: "pending",
+    note,
+    requestedAt: Date.now(),
+    resolvedAt: undefined,
+  });
+}
+
+async function applyStatusTransition(
+  ctx: any,
+  task: any,
+  args: {
+    status: string;
+    agent?: string;
+    note?: string;
+    commitHash?: string;
+    commitMessage?: string;
+    filesChanged?: string[];
+  },
+): Promise<{ commitHash?: string; pendingCommitCapture: boolean }> {
+  const now = Date.now();
+  const history = Array.isArray(task.statusHistory) ? task.statusHistory : [];
+
+  const commitHash =
+    args.status === "done"
+      ? inferCommitHash(task, args.note, args.commitHash)
+      : args.commitHash;
+
+  const patch: Record<string, any> = {
+    status: args.status,
+    updatedAt: now,
+    statusHistory: [
+      ...history,
+      {
+        status: args.status,
+        timestamp: now,
+        agent: args.agent ?? task.agent,
+        note: args.note,
+        commitHash,
+      },
+    ],
+  };
+
+  if (args.status === "in_progress" && !task.startedAt) {
+    patch.startedAt = now;
+  }
+
+  if (args.status === "done") {
+    patch.completedAt = now;
+    if (task.startedAt) {
+      patch.actualHours = Math.round(((now - task.startedAt) / 3_600_000) * 100) / 100;
+    }
+  }
+
+  if (commitHash && args.status === "done") {
+    const commits = Array.isArray(task.commits) ? task.commits : [];
+    const duplicate = commits.some((commit: any) => commit.hash === commitHash);
+    if (!duplicate) {
+      patch.commits = [
+        ...commits,
+        {
+          hash: commitHash,
+          message: args.commitMessage ?? `Task ${task.taskId} completed`,
+          timestamp: now,
+          filesChanged: args.filesChanged,
+          agent: args.agent ?? task.agent,
+        },
+      ];
+    }
+  }
+
+  await ctx.db.patch(task._id, patch);
+
+  if (args.status === "done") {
+    if (commitHash) {
+      await insertCommitCaptureIfMissing(ctx, {
+        taskId: task.taskId,
+        hash: commitHash,
+        message: args.commitMessage ?? `Task ${task.taskId} completed`,
+        source: "status_done",
+        filesChanged: args.filesChanged,
+        capturedBy: args.agent ?? task.agent,
+        capturedAt: now,
+      });
+      await resolvePendingCommitRequests(ctx, task.taskId);
+      return { commitHash, pendingCommitCapture: false };
+    }
+    await ensurePendingCommitRequest(ctx, task.taskId, args.note ?? "Task marked done without commit hash");
+    return { pendingCommitCapture: true };
+  }
+
+  return { commitHash, pendingCommitCapture: false };
+}
+
+// ── Queries ────────────────────────────────────────────────
+
+export const list = query({
+  handler: async (ctx) => {
+    return await ctx.db.query("tasks").collect();
+  },
+});
+
+export const getByTaskId = query({
+  args: { taskId: v.string() },
+  handler: async (ctx, { taskId }) => {
+    return await findTaskByTaskId(ctx, taskId);
+  },
+});
+
+export const stats = query({
+  handler: async (ctx) => {
+    const all = await ctx.db.query("tasks").collect();
+    const byStatus: Record<string, number> = {};
+    const byAgent: Record<string, number> = {};
+    const byPhase: Record<string, number> = {};
+
+    for (const task of all) {
+      byStatus[task.status] = (byStatus[task.status] ?? 0) + 1;
+      byAgent[task.agent] = (byAgent[task.agent] ?? 0) + 1;
+      if (task.phaseId) byPhase[task.phaseId] = (byPhase[task.phaseId] ?? 0) + 1;
+    }
+
+    const done = all.filter((task) => task.status === "done");
+    const withCommits = done.filter((task) => Array.isArray(task.commits) && task.commits.length > 0);
+    const pendingCaptures = await ctx.db
+      .query("pendingCommitCaptures")
+      .withIndex("by_status", (q: any) => q.eq("status", "pending"))
+      .collect();
+
+    return {
+      total: all.length,
+      byStatus,
+      byAgent,
+      byPhase,
+      commitCoverage: { done: done.length, withCommits: withCommits.length },
+      pendingCommitCaptures: pendingCaptures.length,
+    };
+  },
+});
+
+// ── Mutations ──────────────────────────────────────────────
+
+export const create = mutation({
+  args: {
+    taskId: v.string(),
+    projectId: v.string(),
+    agent: v.string(),
+    title: v.string(),
+    description: v.string(),
+    status: v.string(),
+    priority: v.string(),
+    category: v.optional(v.string()),
+    phaseId: v.optional(v.string()),
+    tags: v.optional(v.array(v.string())),
+    dependencies: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, args) => {
+    const now = Date.now();
+    return await ctx.db.insert("tasks", {
+      ...args,
+      createdAt: now,
+      updatedAt: now,
+      statusHistory: [{ status: args.status, timestamp: now, agent: args.agent }],
+      commits: [],
+    } as any);
+  },
+});
+
+export const upsert = mutation({
+  args: {
+    taskId: v.string(),
+    projectId: v.string(),
+    agent: v.string(),
+    title: v.string(),
+    description: v.string(),
+    status: v.string(),
+    priority: v.string(),
+    category: v.optional(v.string()),
+    phaseId: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const existing = await findTaskByTaskId(ctx, args.taskId);
+    if (existing) return { skipped: true, _id: existing._id };
+
+    const now = Date.now();
+    const id = await ctx.db.insert("tasks", {
+      ...args,
+      createdAt: now,
+      updatedAt: now,
+      statusHistory: [{ status: args.status, timestamp: now, agent: args.agent }],
+      commits: [],
+    } as any);
+    return { skipped: false, _id: id };
+  },
+});
+
+export const updateStatus = mutation({
+  args: {
+    id: v.optional(v.id("tasks")),
+    taskId: v.optional(v.string()),
+    status: v.string(),
+    agent: v.optional(v.string()),
+    note: v.optional(v.string()),
+    commitHash: v.optional(v.string()),
+    commitMessage: v.optional(v.string()),
+    filesChanged: v.optional(v.array(v.string())),
+  },
+  handler: async (ctx, args) => {
+    const task = await resolveTask(ctx, { id: args.id, taskId: args.taskId });
+    const result = await applyStatusTransition(ctx, task, {
+      status: args.status,
+      agent: args.agent,
+      note: args.note,
+      commitHash: args.commitHash,
+      commitMessage: args.commitMessage,
+      filesChanged: args.filesChanged,
+    });
+    return {
+      taskId: task.taskId,
+      status: args.status,
+      commitHash: result.commitHash,
+      pendingCommitCapture: result.pendingCommitCapture,
+    };
+  },
+});
+
+export const markDoneWithCommit = mutation({
+  args: {
+    taskId: v.string(),
+    commitHash: v.string(),
+    commitMessage: v.optional(v.string()),
+    filesChanged: v.optional(v.array(v.string())),
+    agent: v.optional(v.string()),
+    note: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const task = await resolveTask(ctx, { taskId: args.taskId });
+    const result = await applyStatusTransition(ctx, task, {
+      status: "done",
+      agent: args.agent,
+      note: args.note ?? "Marked done with explicit commit hash",
+      commitHash: args.commitHash,
+      commitMessage: args.commitMessage,
+      filesChanged: args.filesChanged,
+    });
+    return { taskId: args.taskId, status: "done", commitHash: result.commitHash };
+  },
+});
+
+export const captureCommitFromGitHook = mutation({
+  args: {
+    taskId: v.string(),
+    hash: v.string(),
+    message: v.string(),
+    filesChanged: v.optional(v.array(v.string())),
+    capturedBy: v.optional(v.string()),
+    markDoneIfNeeded: v.optional(v.boolean()),
+  },
+  handler: async (ctx, args) => {
+    const task = await findTaskByTaskId(ctx, args.taskId);
+    if (!task) throw new Error(`Task ${args.taskId} not found`);
+
+    const now = Date.now();
+    const commits = Array.isArray(task.commits) ? task.commits : [];
+    const duplicate = commits.some((commit: any) => commit.hash === args.hash);
+
+    if (!duplicate) {
+      await ctx.db.patch(task._id, {
+        updatedAt: now,
+        commits: [
+          ...commits,
+          {
+            hash: args.hash,
+            message: args.message,
+            timestamp: now,
+            filesChanged: args.filesChanged,
+            agent: args.capturedBy ?? task.agent,
+          },
+        ],
+      });
+    }
+
+    await insertCommitCaptureIfMissing(ctx, {
+      taskId: args.taskId,
+      hash: args.hash,
+      message: args.message,
+      source: "hook",
+      filesChanged: args.filesChanged,
+      capturedBy: args.capturedBy,
+      capturedAt: now,
+    });
+
+    await resolvePendingCommitRequests(ctx, args.taskId);
+
+    if ((args.markDoneIfNeeded ?? true) && task.status !== "done") {
+      await applyStatusTransition(ctx, task, {
+        status: "done",
+        agent: args.capturedBy ?? task.agent,
+        note: `Auto-marked done by hook with commit ${args.hash}`,
+        commitHash: args.hash,
+        commitMessage: args.message,
+        filesChanged: args.filesChanged,
+      });
+    }
+
+    return { taskId: args.taskId, hash: args.hash, attached: !duplicate };
+  },
+});
+
+export const addCommit = mutation({
+  args: {
+    id: v.optional(v.id("tasks")),
+    taskId: v.optional(v.string()),
+    hash: v.string(),
+    message: v.string(),
+    filesChanged: v.optional(v.array(v.string())),
+    agent: v.optional(v.string()),
+  },
+  handler: async (ctx, args) => {
+    const task = await resolveTask(ctx, { id: args.id, taskId: args.taskId });
+    const commits = Array.isArray(task.commits) ? task.commits : [];
+    const duplicate = commits.some((commit: any) => commit.hash === args.hash);
+
+    if (!duplicate) {
+      await ctx.db.patch(task._id, {
+        updatedAt: Date.now(),
+        commits: [
+          ...commits,
+          {
+            hash: args.hash,
+            message: args.message,
+            timestamp: Date.now(),
+            filesChanged: args.filesChanged,
+            agent: args.agent,
+          },
+        ],
+      });
+    }
+
+    await insertCommitCaptureIfMissing(ctx, {
+      taskId: task.taskId,
+      hash: args.hash,
+      message: args.message,
+      source: "manual",
+      filesChanged: args.filesChanged,
+      capturedBy: args.agent,
+    });
+
+    await resolvePendingCommitRequests(ctx, task.taskId);
+    return { taskId: task.taskId, duplicate };
+  },
+});
+
+export const addBlocker = mutation({
+  args: {
+    id: v.id("tasks"),
+    reason: v.string(),
+  },
+  handler: async (ctx, { id, reason }) => {
+    const task = await ctx.db.get(id);
+    if (!task) throw new Error("Task not found");
+    const blockers = task.blockers ?? [];
+    await ctx.db.patch(id, {
+      updatedAt: Date.now(),
+      blockers: [...blockers, { reason, createdAt: Date.now() }],
+    });
+  },
+});
+
+export const resolveBlocker = mutation({
+  args: {
+    id: v.id("tasks"),
+    blockerIndex: v.number(),
+    resolvedBy: v.string(),
+  },
+  handler: async (ctx, { id, blockerIndex, resolvedBy }) => {
+    const task = await ctx.db.get(id);
+    if (!task) throw new Error("Task not found");
+    const blockers = [...(task.blockers ?? [])];
+    if (blockerIndex >= 0 && blockerIndex < blockers.length) {
+      blockers[blockerIndex] = {
+        ...blockers[blockerIndex],
+        resolvedAt: Date.now(),
+        resolvedBy,
+      };
+    }
+    await ctx.db.patch(id, { updatedAt: Date.now(), blockers });
+  },
+});
+
+export const updateNotes = mutation({
+  args: {
+    id: v.id("tasks"),
+    notes: v.string(),
+  },
+  handler: async (ctx, { id, notes }) => {
+    await ctx.db.patch(id, { notes, updatedAt: Date.now() });
+  },
+});