@critical-path/core 0.21.0 → 0.22.0

package/src/domain/errors.ts

@@ -0,0 +1,19 @@
+/**
+ * Thrown when input fails a domain rule. Route handlers map it to HTTP 400.
+ */
+export class ValidationError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'ValidationError';
+  }
+}
+
+/**
+ * Thrown when a referenced entity does not exist. Route handlers map it to HTTP 404.
+ */
+export class NotFoundError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'NotFoundError';
+  }
+}

package/src/domain/events.ts

@@ -134,6 +134,11 @@ export interface ProjectUpdatedEvent extends DomainEvent<{ project: Project; pre
   readonly aggregateType: 'Project';
 }
 
+export interface ProjectDeletedEvent extends DomainEvent<{ projectId: string; name: string; deletedTaskIds: string[] }> {
+  readonly name: 'project.deleted';
+  readonly aggregateType: 'Project';
+}
+
 export interface WorkflowCreatedEvent extends DomainEvent<{ workflow: Workflow }> {
   readonly name: 'workflow.created';
   readonly aggregateType: 'Workflow';
@@ -207,6 +212,7 @@ export type CriticalPathDomainEvent =
   | TaskDependencyAddedEvent
   | ProjectCreatedEvent
   | ProjectUpdatedEvent
+  | ProjectDeletedEvent
   | WorkflowCreatedEvent
   | WorkflowUpdatedEvent
   | WorkflowDeletedEvent

package/src/domain/index.ts

@@ -1,6 +1,7 @@
 export * from './events.js';
 export * from './custom-fields.js';
 export * from './graph.js';
+export * from './errors.js';
 export * from './entities.js';
 export * from './cpm.js';
 export * from './ladder.js';

package/src/engine/index.ts

@@ -56,6 +56,7 @@ import {
   TaskDeletedEvent,
   ProjectCreatedEvent,
   ProjectUpdatedEvent,
+  ProjectDeletedEvent,
   WorkflowCreatedEvent,
   WorkflowUpdatedEvent,
   WorkflowDeletedEvent,
@@ -80,6 +81,7 @@ import {
 import { validateAttachmentUrl, AttachmentValidationError } from '../domain/entities.js';
 import { validateCustomFieldValues } from '../domain/custom-fields.js';
 import { detectDependencyCycle, CircularDependencyError } from '../domain/graph.js';
+import { ValidationError, NotFoundError } from '../domain/errors.js';
 import { calculateCPM, type CPMOptions } from '../domain/cpm.js';
 import { buildTimelineLadder, aggregateConcreteEvidenceForTask } from '../domain/ladder.js';
 import {
@@ -340,6 +342,46 @@ export class CriticalPathEngine {
     return updated;
   }
 
+  /**
+   * Deletes a project and its tasks. Each task goes through `deleteTask`, so plugin
+   * hooks run and `task.deleted` events fire before `project.deleted` is published.
+   */
+  async deleteProject(id: string): Promise<boolean> {
+    const existing = await this.store.getProject(id);
+    if (!existing) return false;
+
+    const tasks = await this.store.getTasks(id);
+    const deletedTaskIds: string[] = [];
+    for (const task of tasks) {
+      if (await this.deleteTask(task.id)) {
+        deletedTaskIds.push(task.id);
+      }
+    }
+
+    const deleted = await this.store.deleteProject(id);
+    if (deleted) {
+      const now = new Date().toISOString();
+      const event: ProjectDeletedEvent = {
+        id: `evt_${Math.random().toString(36).substring(2, 9)}`,
+        name: 'project.deleted',
+        aggregateId: id,
+        aggregateType: 'Project',
+        occurredAt: now,
+        payload: { projectId: id, name: existing.name, deletedTaskIds }
+      };
+      await this.events.publish(event);
+
+      await this.store.logActivity({
+        projectId: id,
+        actorId: 'system',
+        action: 'project.deleted',
+        details: { name: existing.name, deletedTaskCount: deletedTaskIds.length }
+      });
+      this.dispatchWebhook('project.deleted', { projectId: id, name: existing.name, deletedTaskIds });
+    }
+    return deleted;
+  }
+
   // --- Tasks ---
   async getTasks(projectId?: string): Promise<Task[]> {
     return this.store.getTasks(projectId);
@@ -916,14 +958,9 @@ export class CriticalPathEngine {
 
   // --- Task Dependencies & Graph ---
   async addDependency(dep: Omit<TaskDependency, 'id'>): Promise<TaskDependency> {
-    const existingDependencies = await this.store.getDependencies(dep.taskId);
-    const allProjectDeps = [
-      ...existingDependencies,
-      ...(await this.store.getDependencies(dep.dependsOnTaskId))
-    ];
-
     // Enforce Directed Acyclic Graph (DAG) Invariant
-    const cycleCheck = detectDependencyCycle(allProjectDeps, dep);
+    const reachableDeps = await this.collectUpstreamDependencies(dep.dependsOnTaskId);
+    const cycleCheck = detectDependencyCycle(reachableDeps, dep);
     if (cycleCheck.hasCycle) {
       throw new CircularDependencyError(dep.taskId, dep.dependsOnTaskId, cycleCheck.cyclePath);
     }
@@ -944,6 +981,37 @@ export class CriticalPathEngine {
     return created;
   }
 
+  /**
+   * Collects every dependency edge reachable upstream from `startTaskId`. A new edge
+   * `taskId -> dependsOnTaskId` creates a cycle exactly when `taskId` is reachable from
+   * `dependsOnTaskId`, so this is the full set of edges the cycle check needs.
+   */
+  private async collectUpstreamDependencies(startTaskId: string): Promise<TaskDependency[]> {
+    const edges = new Map<string, TaskDependency>();
+    const visited = new Set<string>();
+    let frontier = [startTaskId];
+
+    while (frontier.length > 0) {
+      const next: string[] = [];
+      const results = await Promise.all(frontier.map((id) => this.store.getDependencies(id)));
+      frontier.forEach((id) => visited.add(id));
+
+      for (const deps of results) {
+        for (const d of deps) {
+          // getDependencies returns edges in both directions; follow only outgoing ones.
+          if (!visited.has(d.taskId)) continue;
+          edges.set(d.id, d);
+          if (!visited.has(d.dependsOnTaskId) && !next.includes(d.dependsOnTaskId)) {
+            next.push(d.dependsOnTaskId);
+          }
+        }
+      }
+      frontier = next;
+    }
+
+    return Array.from(edges.values());
+  }
+
   async getTaskDependencyGraph(taskId: string): Promise<TaskDependencyGraph> {
     const dependencies = await this.store.getDependencies(taskId);
     const upstreamTaskIds = new Set<string>();
@@ -996,8 +1064,8 @@ export class CriticalPathEngine {
 
   // --- Time Tracking ---
   async logTime(entry: Omit<TimeEntry, 'id' | 'loggedAt' | 'userId'> & { userId?: string; loggedAt?: string }): Promise<TimeEntry> {
-    if (entry.hours <= 0) {
-      throw new Error('Logged hours must be a positive number.');
+    if (!Number.isFinite(entry.hours) || entry.hours <= 0) {
+      throw new ValidationError('Logged hours must be a positive number.');
     }
 
     const task = await this.store.getTask(entry.taskId);
@@ -1288,7 +1356,7 @@ export class CriticalPathEngine {
   async readAttachmentText(id: string): Promise<string> {
     const attachment = await this.getAttachment(id);
     if (!attachment) {
-      throw new Error(`Attachment with id "${id}" not found.`);
+      throw new NotFoundError(`Attachment with id "${id}" not found.`);
     }
 
     if (attachment.storageKey && this.fileStorage && typeof this.fileStorage.download === 'function') {
@@ -1661,7 +1729,7 @@ export class CriticalPathEngine {
   ): Promise<TimelineLadder> {
     const project = await this.store.getProject(projectId);
     if (!project) {
-      throw new Error(`Project with ID "${projectId}" not found.`);
+      throw new NotFoundError(`Project with ID "${projectId}" not found.`);
     }
 
     let tasks = await this.store.getTasks(projectId);

package/src/index.test.ts

@@ -3,6 +3,30 @@ import { CriticalPathEngine, deriveTaskLifecycleState, DEFAULT_VFX_WORKFLOW } fr
 import type { CriticalPathPlugin } from './types/index.js';
 
 describe('CriticalPathEngine Core Tests', () => {
+  it('deletes a project with its tasks and publishes deletion events', async () => {
+    const engine = new CriticalPathEngine();
+    const proj = await engine.createProject({ key: 'DEL', name: 'Doomed Project' });
+    const keep = await engine.createProject({ key: 'KEEP', name: 'Survivor' });
+    const t1 = await engine.createTask({ projectId: proj.id, title: 'One' });
+    const t2 = await engine.createTask({ projectId: proj.id, title: 'Two' });
+    const other = await engine.createTask({ projectId: keep.id, title: 'Other' });
+
+    const published: string[] = [];
+    engine.events.subscribe('*', (event) => {
+      published.push(event.name);
+    });
+
+    expect(await engine.deleteProject(proj.id)).toBe(true);
+    expect(await engine.getProject(proj.id)).toBeNull();
+    expect(await engine.getTask(t1.id)).toBeNull();
+    expect(await engine.getTask(t2.id)).toBeNull();
+    expect(await engine.getTask(other.id)).not.toBeNull();
+    expect(published.filter((n) => n === 'task.deleted')).toHaveLength(2);
+    expect(published.at(-1)).toBe('project.deleted');
+
+    expect(await engine.deleteProject(proj.id)).toBe(false);
+  });
+
   it('creates projects and tasks with activity logs', async () => {
     const engine = new CriticalPathEngine();
 

package/src/store/sqlite.test.ts

@@ -1,4 +1,7 @@
 import { describe, it, expect, beforeEach } from 'vitest';
+import { execFileSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { fileURLToPath, pathToFileURL } from 'node:url';
 import { SQLiteStore } from './sqlite.js';
 
 describe('SQLiteStore', () => {
@@ -194,3 +197,22 @@ describe('SQLiteStore', () => {
     expect(remaining).toHaveLength(0);
   });
 });
+
+describe('SQLiteStore outside the vitest runtime', () => {
+  const distEntry = fileURLToPath(new URL('../../dist/index.js', import.meta.url));
+
+  // vitest injects `require` into ESM modules, which once hid an `eval("require(...)")` failure
+  // that broke `new SQLiteStore({ filename })` in plain Node. Run the built package in a real Node process.
+  it.skipIf(!existsSync(distEntry))('constructs from a filename in a plain Node ESM process', () => {
+    const script = `
+      const { SQLiteStore } = await import(${JSON.stringify(pathToFileURL(distEntry).href)});
+      const store = new SQLiteStore({ filename: ':memory:' });
+      const project = await store.createProject({ key: 'SMOKE', name: 'Smoke' });
+      process.stdout.write(project.key);
+    `;
+    const output = execFileSync(process.execPath, ['--input-type=module', '--no-warnings', '-e', script], {
+      encoding: 'utf8'
+    });
+    expect(output).toBe('SMOKE');
+  });
+});

package/src/store/sqlite.ts

@@ -41,7 +41,13 @@ export class SQLiteStore implements StorageAdapter {
         throw new Error('SQLiteStore is only available in Node.js environments.');
       }
       try {
-        const nodeSqlite = eval("require('node:sqlite')");
+        // `require` is undefined in ESM, and a static import would break browser bundles of core.
+        const nodeSqlite = (globalThis as any).process?.getBuiltinModule?.('node:sqlite') as
+          | typeof import('node:sqlite')
+          | undefined;
+        if (!nodeSqlite) {
+          throw new Error('process.getBuiltinModule is unavailable (requires Node.js 22.3+)');
+        }
         this.db = new nodeSqlite.DatabaseSync(config.filename || ':memory:');
       } catch (err: any) {
         throw new Error(`Failed to load node:sqlite module: ${err.message}`);

package/src/types/index.ts

@@ -409,6 +409,7 @@ export interface Webhook {
 export type WebhookEvent =
   | 'project.created'
   | 'project.updated'
+  | 'project.deleted'
   | 'task.created'
   | 'task.updated'
   | 'task.deleted'

package/src/utils/fractional-index.test.ts

@@ -120,6 +120,43 @@ describe('fractional-index', () => {
         current = next;
       }
     });
+
+    it('handles repeated insertions directly after the same lower bound', () => {
+      const lower = 'a0';
+      let upper = 'a1';
+
+      // Repeatedly drop a card just below the first card
+      for (let i = 0; i < 50; i++) {
+        const next = generateKeyBetween(lower, upper);
+        expect(lower < next).toBe(true);
+        expect(next < upper).toBe(true);
+        upper = next;
+      }
+    });
+
+    it('keeps keys strictly ordered under random insertions', () => {
+      const keys = ['a0', 'a1'];
+      let seed = 42;
+      const random = () => {
+        seed = (seed * 1103515245 + 12345) % 2147483648;
+        return seed / 2147483648;
+      };
+
+      for (let i = 0; i < 500; i++) {
+        const idx = Math.floor(random() * (keys.length + 1));
+        const next = generateKeyBetween(keys[idx - 1] ?? null, keys[idx] ?? null);
+        keys.splice(idx, 0, next);
+      }
+
+      for (let i = 1; i < keys.length; i++) {
+        expect(keys[i - 1] < keys[i]).toBe(true);
+      }
+    });
+
+    it('throws when the lower bound does not sort before the upper bound', () => {
+      expect(() => generateKeyBetween('a1', 'a0')).toThrow(RangeError);
+      expect(() => generateKeyBetween('a0', 'a0')).toThrow(RangeError);
+    });
   });
 
   describe('generateNKeysBetween', () => {

package/src/utils/fractional-index.ts

@@ -108,40 +108,35 @@ export function getIntegerPart(key: string): string {
 }
 
 /**
- * Computes a fractional midpoint suffix between suffixA and suffixB.
+ * Computes a fractional suffix strictly between suffixes `a` and `b` (a < result < b).
+ * Missing digits in `a` are treated as '0', so `a` may be shorter than `b`.
+ * `b === null` means there is no upper bound.
  */
 function midpointSuffix(a: string, b: string | null): string {
-  let i = 0;
-  while (i < a.length && b !== null && i < b.length && a[i] === b[i]) {
-    i++;
+  if (b !== null) {
+    let n = 0;
+    while (n < b.length && (a[n] ?? '0') === b[n]) {
+      n++;
+    }
+    if (n > 0) {
+      return b.slice(0, n) + midpointSuffix(a.slice(n), b.slice(n));
+    }
   }
 
-  const common = a.slice(0, i);
-  const charA = i < a.length ? a[i] : null;
-  const charB = b !== null && i < b.length ? b[i] : null;
-
-  const digitA = charA !== null ? BASE_62.indexOf(charA) : 0;
-  const digitB = charB !== null ? BASE_62.indexOf(charB) : BASE_62.length;
+  const digitA = a.length > 0 ? BASE_62.indexOf(a[0]) : 0;
+  const digitB = b !== null ? BASE_62.indexOf(b[0]) : BASE_62.length;
 
   if (digitB - digitA > 1) {
-    const mid = Math.floor((digitA + digitB) / 2);
-    return common + BASE_62[mid];
+    return BASE_62[Math.floor((digitA + digitB) / 2)];
   }
 
-  if (charA !== null) {
-    const restA = a.slice(i + 1);
-    const restB = b !== null && i < b.length && charA === charB ? b.slice(i + 1) : null;
-    return common + charA + midpointSuffix(restA, restB);
-  }
-
-  if (b !== null && i < b.length) {
-    if (digitB === 0) {
-      const restB = b.slice(i + 1);
-      return common + '0' + midpointSuffix('', restB);
-    }
+  // Adjacent digits: if b has more digits, its first digit alone already sits between a and b.
+  if (b !== null && b.length > 1) {
+    return b[0];
   }
 
-  return common + 'V';
+  // Otherwise keep a's digit and subdivide the remainder with no upper bound.
+  return BASE_62[digitA] + midpointSuffix(a.slice(1), null);
 }
 
 /**
@@ -185,8 +180,7 @@ export function generateKeyBetween(
 
   // Both a and b are present
   if (a! >= b!) {
-    // Graceful fallback for inverted or equal keys
-    return a! + 'V';
+    throw new RangeError(`generateKeyBetween: lower bound "${a}" must sort before upper bound "${b}"`);
   }
 
   const intA = getIntegerPart(a!);

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/deliverables.test.ts","./src/index.test.ts","./src/index.ts","./src/status.test.ts","./src/task-state.test.ts","./src/use-case-validation.test.ts","./src/domain/calendar.test.ts","./src/domain/calendar.ts","./src/domain/cpm.test.ts","./src/domain/cpm.ts","./src/domain/custom-fields.ts","./src/domain/ddd.test.ts","./src/domain/entities.ts","./src/domain/events.ts","./src/domain/graph.ts","./src/domain/index.ts","./src/domain/ladder.test.ts","./src/domain/ladder.ts","./src/domain/metrics.test.ts","./src/domain/metrics.ts","./src/domain/task-duration.test.ts","./src/domain/workload.test.ts","./src/domain/workload.ts","./src/engine/index.ts","./src/plugins/index.ts","./src/storage/file-storage.ts","./src/storage/firebase-storage.ts","./src/storage/index.ts","./src/storage/s3.ts","./src/storage/storage.test.ts","./src/store/firebase.test.ts","./src/store/firebase.ts","./src/store/index.ts","./src/store/sqlite.test.ts","./src/store/sqlite.ts","./src/types/index.ts","./src/utils/fractional-index.test.ts","./src/utils/fractional-index.ts","./src/utils/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/mentions.test.ts","./src/utils/mentions.ts","./src/utils/status.ts","./src/utils/workflow.ts"],"version":"5.9.3"}
+{"root":["./src/deliverables.test.ts","./src/index.test.ts","./src/index.ts","./src/status.test.ts","./src/task-state.test.ts","./src/use-case-validation.test.ts","./src/domain/calendar.test.ts","./src/domain/calendar.ts","./src/domain/cpm.test.ts","./src/domain/cpm.ts","./src/domain/custom-fields.ts","./src/domain/ddd.test.ts","./src/domain/entities.ts","./src/domain/errors.ts","./src/domain/events.ts","./src/domain/graph.ts","./src/domain/index.ts","./src/domain/ladder.test.ts","./src/domain/ladder.ts","./src/domain/metrics.test.ts","./src/domain/metrics.ts","./src/domain/task-duration.test.ts","./src/domain/workload.test.ts","./src/domain/workload.ts","./src/engine/index.ts","./src/plugins/index.ts","./src/storage/file-storage.ts","./src/storage/firebase-storage.ts","./src/storage/index.ts","./src/storage/s3.ts","./src/storage/storage.test.ts","./src/store/firebase.test.ts","./src/store/firebase.ts","./src/store/index.ts","./src/store/sqlite.test.ts","./src/store/sqlite.ts","./src/types/index.ts","./src/utils/fractional-index.test.ts","./src/utils/fractional-index.ts","./src/utils/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/mentions.test.ts","./src/utils/mentions.ts","./src/utils/status.ts","./src/utils/workflow.ts"],"version":"5.9.3"}