trekoon 0.3.5 → 0.3.7

package/src/board/snapshot.ts

@@ -1,11 +1,7 @@
 import { TrackerDomain } from "../domain/tracker-domain";
 import { type DependencyRecord, type EpicRecord, type SubtaskRecord, type TaskRecord } from "../domain/types";
 
-interface SearchFields {
-  readonly title: string;
-  readonly description: string;
-  readonly text: string;
-}
+type BoardStatus = "todo" | "blocked" | "in_progress" | "done";
 
 interface StatusCounts {
   readonly total: number;
@@ -16,65 +12,63 @@ interface StatusCounts {
   readonly other: number;
 }
 
-export interface BoardSnapshotEpic {
+interface FlatCounts extends Record<BoardStatus, number> {}
+
+export interface BoardSnapshotDependency {
   readonly id: string;
-  readonly title: string;
-  readonly description: string;
-  readonly status: string;
+  readonly sourceId: string;
+  readonly sourceKind: "task" | "subtask";
+  readonly dependsOnId: string;
+  readonly dependsOnKind: "task" | "subtask";
   readonly createdAt: number;
   readonly updatedAt: number;
-  readonly taskIds: readonly string[];
-  readonly counts: {
-    readonly tasks: StatusCounts;
-    readonly subtasks: StatusCounts;
-  };
-  readonly search: SearchFields;
 }
 
-export interface BoardSnapshotTask {
+interface BoardSnapshotSubtask {
   readonly id: string;
-  readonly epicId: string;
+  readonly kind: "subtask";
+  readonly taskId: string;
   readonly title: string;
   readonly description: string;
   readonly status: string;
+  readonly owner: string | null;
   readonly createdAt: number;
   readonly updatedAt: number;
-  readonly subtaskIds: readonly string[];
+  readonly blockedBy: readonly string[];
+  readonly blocks: readonly string[];
   readonly dependencyIds: readonly string[];
   readonly dependentIds: readonly string[];
-  readonly counts: {
-    readonly subtasks: StatusCounts;
-    readonly dependencies: number;
-    readonly dependents: number;
-  };
-  readonly search: SearchFields;
+  readonly searchText: string;
 }
 
-export interface BoardSnapshotSubtask {
+interface BoardSnapshotTask {
   readonly id: string;
-  readonly taskId: string;
+  readonly kind: "task";
+  readonly epicId: string;
   readonly title: string;
   readonly description: string;
   readonly status: string;
+  readonly owner: string | null;
   readonly createdAt: number;
   readonly updatedAt: number;
+  readonly blockedBy: readonly string[];
+  readonly blocks: readonly string[];
   readonly dependencyIds: readonly string[];
   readonly dependentIds: readonly string[];
-  readonly counts: {
-    readonly dependencies: number;
-    readonly dependents: number;
-  };
-  readonly search: SearchFields;
+  readonly subtasks: readonly BoardSnapshotSubtask[];
+  readonly searchText: string;
 }
 
-export interface BoardSnapshotDependency {
+interface BoardSnapshotEpic {
   readonly id: string;
-  readonly sourceId: string;
-  readonly sourceKind: "task" | "subtask";
-  readonly dependsOnId: string;
-  readonly dependsOnKind: "task" | "subtask";
+  readonly title: string;
+  readonly description: string;
+  readonly status: string;
   readonly createdAt: number;
   readonly updatedAt: number;
+  readonly taskIds: readonly string[];
+  readonly counts: FlatCounts;
+  readonly searchText: string;
 }
 
 export interface BoardSnapshot {
@@ -92,56 +86,31 @@ export interface BoardSnapshot {
 }
 
 function normalizeStatusBucket(status: string): keyof Omit<StatusCounts, "total"> {
-  if (status === "todo") {
-    return "todo";
-  }
-
-   if (status === "blocked") {
-    return "blocked";
-  }
-
-  if (status === "in_progress" || status === "in-progress") {
-    return "inProgress";
-  }
-
-  if (status === "done") {
-    return "done";
-  }
-
+  if (status === "todo") return "todo";
+  if (status === "blocked") return "blocked";
+  if (status === "in_progress" || status === "in-progress") return "inProgress";
+  if (status === "done") return "done";
   return "other";
 }
 
 function countStatuses(records: readonly { readonly status: string }[]): StatusCounts {
-  const counts: {
-    total: number;
-    todo: number;
-    blocked: number;
-    inProgress: number;
-    done: number;
-    other: number;
-  } = {
-    total: records.length,
-    todo: 0,
-    blocked: 0,
-    inProgress: 0,
-    done: 0,
-    other: 0,
-  };
-
+  const counts = { total: records.length, todo: 0, blocked: 0, inProgress: 0, done: 0, other: 0 };
   for (const record of records) {
-    const bucket = normalizeStatusBucket(record.status);
-    counts[bucket] += 1;
+    counts[normalizeStatusBucket(record.status)] += 1;
   }
-
   return counts;
 }
 
-function buildSearchFields(title: string, description: string): SearchFields {
-  return {
-    title,
-    description,
-    text: `${title}\n${description}`.trim(),
-  };
+function deriveFlatCounts(records: readonly { readonly status: string }[]): FlatCounts {
+  return records.reduce<FlatCounts>(
+    (counts, record) => {
+      if (record.status === "todo" || record.status === "blocked" || record.status === "in_progress" || record.status === "done") {
+        counts[record.status] += 1;
+      }
+      return counts;
+    },
+    { todo: 0, blocked: 0, in_progress: 0, done: 0 },
+  );
 }
 
 function mapDependency(record: DependencyRecord): BoardSnapshotDependency {
@@ -157,115 +126,129 @@ function mapDependency(record: DependencyRecord): BoardSnapshotDependency {
 }
 
 export function buildBoardSnapshot(domain: TrackerDomain): BoardSnapshot {
-  const generatedAt: number = Date.now();
-  const epics: readonly EpicRecord[] = domain.listEpics();
-  const tasks: readonly TaskRecord[] = domain.listTasks();
-  const subtasks: readonly SubtaskRecord[] = domain.listSubtasks();
+  const generatedAt = Date.now();
+  const epics = domain.listEpics();
+  const tasks = domain.listTasks();
+  const subtasks = domain.listSubtasks();
+  const sourceIds = [...tasks.map((task) => task.id), ...subtasks.map((subtask) => subtask.id)];
+  const dependenciesBySourceId = domain.listDependenciesBySourceIds(sourceIds);
+  const subtasksByTaskId = new Map<string, SubtaskRecord[]>();
+  const tasksByEpicId = new Map<string, TaskRecord[]>();
+  const dependencyIdsBySource = new Map<string, string[]>();
+  const blockedByIdsBySource = new Map<string, string[]>();
+  const dependentIdsByTarget = new Map<string, string[]>();
+  const blocksByTarget = new Map<string, string[]>();
   const dependencies: BoardSnapshotDependency[] = [];
 
-  const tasksByEpic = new Map<string, TaskRecord[]>();
   for (const task of tasks) {
-    const existing = tasksByEpic.get(task.epicId) ?? [];
+    const existing = tasksByEpicId.get(task.epicId) ?? [];
     existing.push(task);
-    tasksByEpic.set(task.epicId, existing);
+    tasksByEpicId.set(task.epicId, existing);
   }
 
-  const subtasksByTask = new Map<string, SubtaskRecord[]>();
   for (const subtask of subtasks) {
-    const existing = subtasksByTask.get(subtask.taskId) ?? [];
+    const existing = subtasksByTaskId.get(subtask.taskId) ?? [];
     existing.push(subtask);
-    subtasksByTask.set(subtask.taskId, existing);
+    subtasksByTaskId.set(subtask.taskId, existing);
   }
 
-  const dependencyIdsBySource = new Map<string, string[]>();
-  const dependentIdsByTarget = new Map<string, string[]>();
-  for (const task of tasks) {
-    for (const dependency of domain.listDependencies(task.id)) {
+  for (const sourceId of sourceIds) {
+    for (const dependency of dependenciesBySourceId.get(sourceId) ?? []) {
       dependencies.push(mapDependency(dependency));
-      const sourceIds = dependencyIdsBySource.get(dependency.sourceId) ?? [];
-      sourceIds.push(dependency.id);
-      dependencyIdsBySource.set(dependency.sourceId, sourceIds);
-      const dependentIds = dependentIdsByTarget.get(dependency.dependsOnId) ?? [];
-      dependentIds.push(dependency.id);
-      dependentIdsByTarget.set(dependency.dependsOnId, dependentIds);
+
+      const sourceDependencyIds = dependencyIdsBySource.get(dependency.sourceId) ?? [];
+      sourceDependencyIds.push(dependency.id);
+      dependencyIdsBySource.set(dependency.sourceId, sourceDependencyIds);
+
+      const sourceBlockedBy = blockedByIdsBySource.get(dependency.sourceId) ?? [];
+      sourceBlockedBy.push(dependency.dependsOnId);
+      blockedByIdsBySource.set(dependency.sourceId, sourceBlockedBy);
+
+      const targetDependentIds = dependentIdsByTarget.get(dependency.dependsOnId) ?? [];
+      targetDependentIds.push(dependency.id);
+      dependentIdsByTarget.set(dependency.dependsOnId, targetDependentIds);
+
+      const targetBlocks = blocksByTarget.get(dependency.dependsOnId) ?? [];
+      targetBlocks.push(dependency.sourceId);
+      blocksByTarget.set(dependency.dependsOnId, targetBlocks);
     }
   }
 
-  for (const subtask of subtasks) {
-    for (const dependency of domain.listDependencies(subtask.id)) {
-      dependencies.push(mapDependency(dependency));
-      const sourceIds = dependencyIdsBySource.get(dependency.sourceId) ?? [];
-      sourceIds.push(dependency.id);
-      dependencyIdsBySource.set(dependency.sourceId, sourceIds);
-      const dependentIds = dependentIdsByTarget.get(dependency.dependsOnId) ?? [];
-      dependentIds.push(dependency.id);
-      dependentIdsByTarget.set(dependency.dependsOnId, dependentIds);
-    }
+  const snapshotSubtasks: BoardSnapshotSubtask[] = subtasks.map((subtask) => ({
+    id: subtask.id,
+    kind: "subtask",
+    taskId: subtask.taskId,
+    title: subtask.title,
+    description: subtask.description,
+    status: subtask.status,
+    owner: subtask.owner ?? null,
+    createdAt: subtask.createdAt,
+    updatedAt: subtask.updatedAt,
+    blockedBy: blockedByIdsBySource.get(subtask.id) ?? [],
+    blocks: blocksByTarget.get(subtask.id) ?? [],
+    dependencyIds: dependencyIdsBySource.get(subtask.id) ?? [],
+    dependentIds: dependentIdsByTarget.get(subtask.id) ?? [],
+    searchText: [subtask.title, subtask.description, subtask.status].join(" ").toLowerCase(),
+  }));
+  const snapshotSubtasksByTaskId = new Map<string, BoardSnapshotSubtask[]>();
+  for (const subtask of snapshotSubtasks) {
+    const existing = snapshotSubtasksByTaskId.get(subtask.taskId) ?? [];
+    existing.push(subtask);
+    snapshotSubtasksByTaskId.set(subtask.taskId, existing);
+  }
+
+  const snapshotTasks: BoardSnapshotTask[] = tasks.map((task) => {
+    const taskSubtasks = snapshotSubtasksByTaskId.get(task.id) ?? [];
+    return {
+      id: task.id,
+      kind: "task",
+      epicId: task.epicId,
+      title: task.title,
+      description: task.description,
+      status: task.status,
+      owner: task.owner ?? null,
+      createdAt: task.createdAt,
+      updatedAt: task.updatedAt,
+      blockedBy: blockedByIdsBySource.get(task.id) ?? [],
+      blocks: blocksByTarget.get(task.id) ?? [],
+      dependencyIds: dependencyIdsBySource.get(task.id) ?? [],
+      dependentIds: dependentIdsByTarget.get(task.id) ?? [],
+      subtasks: taskSubtasks,
+      searchText: [
+        task.title,
+        task.description,
+        task.status,
+        ...taskSubtasks.map((subtask) => `${subtask.title} ${subtask.description} ${subtask.status}`),
+      ].join(" ").toLowerCase(),
+    };
+  });
+  const taskSearchTextByEpicId = new Map<string, string[]>();
+  for (const task of snapshotTasks) {
+    const existing = taskSearchTextByEpicId.get(task.epicId) ?? [];
+    existing.push(task.searchText);
+    taskSearchTextByEpicId.set(task.epicId, existing);
   }
 
+  const snapshotEpics: BoardSnapshotEpic[] = epics.map((epic) => {
+    const epicTasks = tasksByEpicId.get(epic.id) ?? [];
+    return {
+      id: epic.id,
+      title: epic.title,
+      description: epic.description,
+      status: epic.status,
+      createdAt: epic.createdAt,
+      updatedAt: epic.updatedAt,
+      taskIds: epicTasks.map((task) => task.id),
+      counts: deriveFlatCounts(epicTasks),
+      searchText: [epic.title, epic.description, ...(taskSearchTextByEpicId.get(epic.id) ?? [])].join(" ").toLowerCase(),
+    };
+  });
+
   return {
     generatedAt,
-    epics: epics.map((epic) => {
-      const epicTasks = tasksByEpic.get(epic.id) ?? [];
-      const epicSubtasks = epicTasks.flatMap((task) => subtasksByTask.get(task.id) ?? []);
-      return {
-        id: epic.id,
-        title: epic.title,
-        description: epic.description,
-        status: epic.status,
-        createdAt: epic.createdAt,
-        updatedAt: epic.updatedAt,
-        taskIds: epicTasks.map((task) => task.id),
-        counts: {
-          tasks: countStatuses(epicTasks),
-          subtasks: countStatuses(epicSubtasks),
-        },
-        search: buildSearchFields(epic.title, epic.description),
-      };
-    }),
-    tasks: tasks.map((task) => {
-      const taskSubtasks = subtasksByTask.get(task.id) ?? [];
-      const dependencyIds = dependencyIdsBySource.get(task.id) ?? [];
-      const dependentIds = dependentIdsByTarget.get(task.id) ?? [];
-      return {
-        id: task.id,
-        epicId: task.epicId,
-        title: task.title,
-        description: task.description,
-        status: task.status,
-        createdAt: task.createdAt,
-        updatedAt: task.updatedAt,
-        subtaskIds: taskSubtasks.map((subtask) => subtask.id),
-        dependencyIds,
-        dependentIds,
-        counts: {
-          subtasks: countStatuses(taskSubtasks),
-          dependencies: dependencyIds.length,
-          dependents: dependentIds.length,
-        },
-        search: buildSearchFields(task.title, task.description),
-      };
-    }),
-    subtasks: subtasks.map((subtask) => {
-      const dependencyIds = dependencyIdsBySource.get(subtask.id) ?? [];
-      const dependentIds = dependentIdsByTarget.get(subtask.id) ?? [];
-      return {
-        id: subtask.id,
-        taskId: subtask.taskId,
-        title: subtask.title,
-        description: subtask.description,
-        status: subtask.status,
-        createdAt: subtask.createdAt,
-        updatedAt: subtask.updatedAt,
-        dependencyIds,
-        dependentIds,
-        counts: {
-          dependencies: dependencyIds.length,
-          dependents: dependentIds.length,
-        },
-        search: buildSearchFields(subtask.title, subtask.description),
-      };
-    }),
+    epics: snapshotEpics,
+    tasks: snapshotTasks,
+    subtasks: snapshotSubtasks,
     dependencies,
     counts: {
       epics: countStatuses(epics),

package/src/commands/events.ts

@@ -73,17 +73,23 @@ export async function runEvents(context: CliContext): Promise<CliResult> {
       archive,
     });
 
-    return okResult({
-      command: "events.prune",
-      human: [
-        dryRun ? "Dry run complete." : "Prune complete.",
-        `Retention days: ${summary.retentionDays}`,
-        `Candidates: ${summary.candidateCount}`,
-        `Archived: ${summary.archivedCount}`,
-        `Deleted: ${summary.deletedCount}`,
-      ].join("\n"),
-      data: summary,
-    });
+      return okResult({
+        command: "events.prune",
+        human: [
+          dryRun ? "Dry run complete." : "Prune complete.",
+          `Retention days: ${summary.retentionDays}`,
+          `Candidates: ${summary.candidateCount}`,
+          `Archived: ${summary.archivedCount}`,
+          `Deleted: ${summary.deletedCount}`,
+          summary.staleCursorCount > 0
+            ? `Sync guidance: ${summary.staleCursorCount} cursor(s) reference pruned history. Run 'trekoon sync pull --from <branch>' and rebuild if stale cursor hints persist.`
+            : "Sync guidance: pruning stayed within retained cursor history.",
+          archive
+            ? "Retention automation: archived copies were kept before deletion."
+            : "Retention automation: rerun with --archive to keep retained copies before deletion.",
+        ].join("\n"),
+        data: summary,
+      });
   } catch (error: unknown) {
     const busyFailure = sqliteBusyFailure("events.prune", error);
     if (busyFailure !== null) {

package/src/commands/init.ts

@@ -1,3 +1,6 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolve } from "node:path";
+
 import { unexpectedFailureResult } from "./error-utils";
 
 import { ensureBoardInstalled } from "../board/install";
@@ -6,6 +9,11 @@ import { DomainError } from "../domain/types";
 import { failResult, okResult } from "../io/output";
 import { type CliContext, type CliResult } from "../runtime/command-types";
 import { openTrekoonDatabase, type TrekoonDatabase } from "../storage/database";
+import { type StorageMode } from "../storage/path";
+
+type GitignoreAction = "created" | "already_exists" | "skipped";
+
+const GITIGNORE_CONTENT = "*\n";
 
 function buildRecoverySummary(database: TrekoonDatabase): string[] {
   const diagnostics = database.diagnostics;
@@ -76,6 +84,24 @@ function recoveryFailureResult(error: DomainError): CliResult | null {
   });
 }
 
+function ensureGitignore(storageDir: string, storageMode: StorageMode): GitignoreAction {
+  if (storageMode === "cwd") {
+    return "skipped";
+  }
+
+  const gitignorePath: string = resolve(storageDir, ".gitignore");
+
+  if (existsSync(gitignorePath)) {
+    const existing: string = readFileSync(gitignorePath, "utf8");
+    if (existing === GITIGNORE_CONTENT) {
+      return "already_exists";
+    }
+  }
+
+  writeFileSync(gitignorePath, GITIGNORE_CONTENT, "utf8");
+  return "created";
+}
+
 export async function runInit(context: CliContext): Promise<CliResult> {
   let database: TrekoonDatabase | undefined;
 
@@ -87,6 +113,11 @@ export async function runInit(context: CliContext): Promise<CliResult> {
       workingDirectory: context.cwd,
       ...(bundledAssetRoot === undefined ? {} : { bundledAssetRoot }),
     });
+    const gitignoreAction: GitignoreAction = ensureGitignore(
+      database.paths.storageDir,
+      diagnostics.storageMode,
+    );
+
     const humanLines: string[] = [
       "Trekoon initialized.",
       `Storage mode: ${diagnostics.storageMode}`,
@@ -96,6 +127,7 @@ export async function runInit(context: CliContext): Promise<CliResult> {
       `Database file: ${database.paths.databaseFile}`,
       `Board assets: ${board.action}`,
       `Board runtime root: ${board.paths.runtimeRoot}`,
+      `Gitignore: ${gitignoreAction}`,
       ...buildRecoverySummary(database),
     ];
 
@@ -115,6 +147,10 @@ export async function runInit(context: CliContext): Promise<CliResult> {
           paths: board.paths,
           manifest: board.manifest,
         },
+        gitignore: {
+          action: gitignoreAction,
+          path: resolve(database.paths.storageDir, ".gitignore"),
+        },
         legacyStateDetected: diagnostics.legacyStateDetected,
         recoveryRequired: diagnostics.recoveryRequired,
         recoveryStatus: diagnostics.recoveryStatus,

package/src/commands/subtask.ts

@@ -935,12 +935,12 @@ export async function runSubtask(context: CliContext): Promise<CliResult> {
       }
       case "delete": {
         const subtaskId: string = parsed.positional[1] ?? "";
-        mutations.deleteSubtask(subtaskId);
+        const result = mutations.deleteSubtask(subtaskId);
 
         return okResult({
           command: "subtask.delete",
           human: `Deleted subtask ${subtaskId}`,
-          data: { id: subtaskId },
+          data: { id: subtaskId, deletedDependencyIds: result.deletedDependencyIds },
         });
       }
       default: