trekoon 0.1.9 → 0.2.1

package/src/domain/types.ts

@@ -1,5 +1,85 @@
 export type NodeKind = "epic" | "task" | "subtask";
 
+export const COMPACT_TEMP_KEY_PREFIX = "@";
+
+export type CompactTempKey = string;
+
+export interface CompactTempKeyRef {
+  readonly kind: "temp_key";
+  readonly tempKey: CompactTempKey;
+}
+
+export interface CompactEntityIdRef {
+  readonly kind: "id";
+  readonly id: string;
+}
+
+export type CompactEntityRef = CompactTempKeyRef | CompactEntityIdRef;
+
+export interface CompactTaskSpec {
+  readonly tempKey: CompactTempKey;
+  readonly title: string;
+  readonly description: string;
+  readonly status?: string;
+}
+
+export interface CompactSubtaskSpec {
+  readonly parent: CompactEntityRef;
+  readonly tempKey: CompactTempKey;
+  readonly title: string;
+  readonly description: string;
+  readonly status?: string;
+}
+
+export interface CompactDependencySpec {
+  readonly source: CompactEntityRef;
+  readonly dependsOn: CompactEntityRef;
+}
+
+export interface CompactTempKeyMapping<TKind extends Extract<NodeKind, "task" | "subtask"> = Extract<NodeKind, "task" | "subtask">> {
+  readonly kind: TKind;
+  readonly tempKey: CompactTempKey;
+  readonly id: string;
+}
+
+export interface CompactBatchResultContract {
+  readonly mappings: ReadonlyArray<CompactTempKeyMapping>;
+}
+
+export interface CompactTaskBatchCreateResult {
+  readonly tasks: ReadonlyArray<TaskRecord>;
+  readonly result: CompactBatchResultContract;
+}
+
+export interface CompactSubtaskBatchCreateResult {
+  readonly subtasks: ReadonlyArray<SubtaskRecord>;
+  readonly result: CompactBatchResultContract;
+}
+
+export interface CompactDependencyBatchAddResult {
+  readonly dependencies: ReadonlyArray<DependencyRecord>;
+  readonly result: CompactBatchResultContract;
+}
+
+export interface CompactBatchCounts {
+  readonly tasks: number;
+  readonly subtasks: number;
+  readonly dependencies: number;
+}
+
+export interface CompactEpicExpandResult {
+  readonly tasks: ReadonlyArray<TaskRecord>;
+  readonly subtasks: ReadonlyArray<SubtaskRecord>;
+  readonly dependencies: ReadonlyArray<DependencyRecord>;
+  readonly result: CompactBatchResultContract & {
+    readonly counts: CompactBatchCounts;
+  };
+}
+
+export interface CompactEpicCreateResult extends CompactEpicExpandResult {
+  readonly epic: EpicRecord;
+}
+
 export interface EpicRecord {
   readonly id: string;
   readonly title: string;
@@ -85,6 +165,33 @@ export interface EpicTreeDetailed {
   readonly tasks: ReadonlyArray<TaskTreeDetailed>;
 }
 
+export type SearchField = "title" | "description";
+
+export interface SearchFieldMatch {
+  readonly field: SearchField;
+  readonly count: number;
+  readonly snippet: string;
+}
+
+export interface SearchEntityMatch {
+  readonly kind: NodeKind;
+  readonly id: string;
+  readonly fields: readonly SearchFieldMatch[];
+}
+
+export interface SearchSummary {
+  readonly matchedEntities: number;
+  readonly matchedFields: number;
+  readonly totalMatches: number;
+}
+
+export interface SearchNode {
+  readonly kind: NodeKind;
+  readonly id: string;
+  readonly title: string;
+  readonly description: string;
+}
+
 export interface DomainErrorShape {
   readonly code: string;
   readonly message: string;

package/src/sync/event-writes.ts

@@ -11,11 +11,31 @@ interface EventRecordInput {
   readonly fields: Record<string, unknown>;
 }
 
+function nextEventTimestamp(db: Database): number {
+  const now: number = Date.now();
+  const latestEvent = db
+    .query(
+      `
+      SELECT created_at
+      FROM events
+      ORDER BY created_at DESC, id DESC
+      LIMIT 1;
+      `,
+    )
+    .get() as { created_at: number } | null;
+
+  if (!latestEvent) {
+    return now;
+  }
+
+  return Math.max(now, latestEvent.created_at + 1);
+}
+
 export function appendEventWithGitContext(db: Database, cwd: string, input: EventRecordInput): string {
   const git = resolveGitContext(cwd);
   persistGitContext(db, git);
 
-  const now: number = Date.now();
+  const now: number = nextEventTimestamp(db);
   const eventId: string = randomUUID();
 
   db.query(

package/src/sync/service.ts

@@ -401,6 +401,18 @@ function rowExists(db: Database, tableName: string, id: string): boolean {
   return row !== null;
 }
 
+function dependencyNodeExists(db: Database, nodeKind: string, nodeId: string): boolean {
+  if (nodeKind === "task") {
+    return rowExists(db, "tasks", nodeId);
+  }
+
+  if (nodeKind === "subtask") {
+    return rowExists(db, "subtasks", nodeId);
+  }
+
+  return false;
+}
+
 function validateRequiredStringField(fields: Record<string, unknown>, fieldName: string): string | null {
   const value: unknown = fields[fieldName];
   if (typeof value !== "string" || value.length === 0) {
@@ -503,6 +515,10 @@ function applyCreate(db: Database, event: StoredEvent, fields: Record<string, un
     return false;
   }
 
+  if (!dependencyNodeExists(db, sourceKind, sourceId) || !dependencyNodeExists(db, dependsOnKind, dependsOnId)) {
+    return false;
+  }
+
   db.query(
     `
     INSERT INTO dependencies (
@@ -625,6 +641,28 @@ function applyEntityFields(db: Database, event: StoredEvent, fields: Record<stri
   return false;
 }
 
+function applyReplayedCreateWithConflicts(
+  db: Database,
+  event: StoredEvent,
+  fields: Record<string, unknown>,
+  withheldConflictCount: number,
+): boolean {
+  if (withheldConflictCount === 0 || !event.operation.endsWith(".created")) {
+    return false;
+  }
+
+  const tableName = tableForEntityKind(event.entity_kind);
+  if (!tableName || !rowExists(db, tableName, event.entity_id)) {
+    return false;
+  }
+
+  if (Object.keys(fields).length === 0) {
+    return true;
+  }
+
+  return applyUpdatePatch(db, event, fields);
+}
+
 function storeEvent(db: Database, event: StoredEvent): void {
   db.query(
     `
@@ -727,11 +765,13 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 
         const payload: EventPayload = { fields: payloadValidation.fields };
         const fieldsToApply: Record<string, unknown> = {};
+        let withheldConflictCount = 0;
 
         for (const [fieldName, value] of Object.entries(payload.fields)) {
           const conflict = entityFieldConflict(storage.db, sourceBranch, incoming, fieldName, value);
 
           if (conflict) {
+            withheldConflictCount += 1;
             conflictEvents += 1;
             createConflict(storage.db, incoming, fieldName, conflict.oursValue, conflict.theirsValue);
             createdConflicts += 1;
@@ -743,6 +783,8 @@ export function syncPull(cwd: string, sourceBranch: string): PullSummary {
 
         if (applyEntityFields(storage.db, incoming, fieldsToApply)) {
           appliedEvents += 1;
+        } else if (applyReplayedCreateWithConflicts(storage.db, incoming, fieldsToApply, withheldConflictCount)) {
+          appliedEvents += 1;
         } else if (incoming.operation !== "resolve_conflict") {
           applyRejectedEvents += 1;
           quarantinedEvents += 1;