@critical-path/core 0.2.0 → 0.3.0

package/src/utils/key.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+import { generateProjectKey, validateProjectKey, formatTaskKey } from './key.js';
+
+describe('Project Key Utilities', () => {
+  describe('generateProjectKey', () => {
+    it('generates a key for a single word name', () => {
+      expect(generateProjectKey('Operative')).toBe('OPE');
+      expect(generateProjectKey('App')).toBe('APP');
+      expect(generateProjectKey('Go')).toBe('GO');
+    });
+
+    it('generates a key for multi-word names', () => {
+      expect(generateProjectKey('Mobile App')).toBe('MA');
+      expect(generateProjectKey('Frontend Core Platform')).toBe('FCP');
+      expect(generateProjectKey('Very Long Project Name Here')).toBe('VLPN');
+    });
+
+    it('handles special characters and whitespace', () => {
+      expect(generateProjectKey('  v2.0  ')).toBe('V20');
+      expect(generateProjectKey('Project #1')).toBe('P1');
+    });
+
+    it('returns default PRJ fallback for empty input', () => {
+      expect(generateProjectKey('')).toBe('PRJ');
+      expect(generateProjectKey('   ')).toBe('PRJ');
+    });
+  });
+
+  describe('validateProjectKey', () => {
+    it('returns true for valid keys', () => {
+      expect(validateProjectKey('CP')).toBe(true);
+      expect(validateProjectKey('PROJ')).toBe(true);
+      expect(validateProjectKey('APP123')).toBe(true);
+    });
+
+    it('returns false for invalid keys', () => {
+      expect(validateProjectKey('A')).toBe(false); // too short
+      expect(validateProjectKey('TOOLONGKEY')).toBe(false); // too long
+      expect(validateProjectKey('proj')).toBe(false); // lowercase
+      expect(validateProjectKey('P-1')).toBe(false); // special char
+      expect(validateProjectKey('')).toBe(false);
+    });
+  });
+
+  describe('formatTaskKey', () => {
+    it('formats project key and task number', () => {
+      expect(formatTaskKey('MOB', 42)).toBe('MOB-42');
+      expect(formatTaskKey('op', 1)).toBe('OP-1');
+    });
+
+    it('uses fallback for missing project key', () => {
+      expect(formatTaskKey('', 10)).toBe('TASK-10');
+    });
+  });
+});

package/src/utils/key.ts

@@ -0,0 +1,51 @@
+/**
+ * Generates a 2-6 character uppercase project short code/key from a project name.
+ * e.g., "Mobile App" -> "MA", "Frontend Core" -> "FC", "Operative" -> "OPE".
+ */
+export function generateProjectKey(name: string): string {
+  if (!name || !name.trim()) {
+    return 'PRJ';
+  }
+
+  const words = name.trim().split(/\s+/).filter(Boolean);
+  let rawKey = '';
+
+  if (words.length === 1) {
+    const word = words[0].replace(/[^a-zA-Z0-9]/g, '');
+    if (word.length <= 3) {
+      rawKey = word.toUpperCase();
+    } else {
+      rawKey = word.substring(0, 3).toUpperCase();
+    }
+  } else {
+    rawKey = words
+      .map((w) => w.replace(/[^a-zA-Z0-9]/g, '')[0] || '')
+      .join('')
+      .substring(0, 4)
+      .toUpperCase();
+  }
+
+  // Ensure key meets basic 2-6 char alphanumeric requirement
+  const cleanKey = rawKey.replace(/[^A-Z0-9]/g, '');
+  if (cleanKey.length >= 2 && cleanKey.length <= 6) {
+    return cleanKey;
+  }
+
+  return 'PRJ';
+}
+
+/**
+ * Validates whether a given key meets project key format rules (2-6 uppercase alphanumeric characters).
+ */
+export function validateProjectKey(key: string): boolean {
+  if (!key) return false;
+  return /^[A-Z0-9]{2,6}$/.test(key);
+}
+
+/**
+ * Formats a task key using a project key and task index (e.g. "MOB-12").
+ */
+export function formatTaskKey(projectKey: string, taskNumber: number): string {
+  const prefix = projectKey ? projectKey.toUpperCase() : 'TASK';
+  return `${prefix}-${taskNumber}`;
+}

package/src/utils/status.ts

@@ -0,0 +1,85 @@
+import type {
+  Task,
+  StatusDefinition,
+  CompletionState,
+  ExecutionState
+} from '../types/index.js';
+
+export const DEFAULT_STATUS_DEFINITIONS: Record<string, StatusDefinition> = {
+  backlog: { key: 'backlog', label: 'Backlog', completionState: 'not_done', executionState: 'inactive' },
+  todo: { key: 'todo', label: 'To Do', completionState: 'not_done', executionState: 'inactive' },
+  in_progress: { key: 'in_progress', label: 'In Progress', completionState: 'not_done', executionState: 'active' },
+  in_review: { key: 'in_review', label: 'In Review', completionState: 'not_done', executionState: 'active' },
+  done: { key: 'done', label: 'Done', completionState: 'done', executionState: 'inactive' },
+  canceled: { key: 'canceled', label: 'Canceled', completionState: 'done', executionState: 'inactive', isCancelled: true }
+};
+
+export interface TaskLifecycleState {
+  completionState: CompletionState;
+  executionState: ExecutionState;
+  isDone: boolean;
+  isActive: boolean;
+  isCancelled: boolean;
+  isOverdue: boolean;
+  isUpcoming: boolean;
+}
+
+export function resolveStatusDefinition(
+  statusKey: string,
+  customDefinitions?: StatusDefinition[]
+): StatusDefinition {
+  if (customDefinitions) {
+    const found = customDefinitions.find((def) => def.key === statusKey);
+    if (found) return found;
+  }
+  if (DEFAULT_STATUS_DEFINITIONS[statusKey]) {
+    return DEFAULT_STATUS_DEFINITIONS[statusKey];
+  }
+  // Fallback heuristic for unknown custom statuses:
+  const isDoneKey = ['done', 'completed', 'finished', 'closed', 'canceled', 'cancelled'].includes(statusKey.toLowerCase());
+  const isActiveKey = ['in_progress', 'active', 'working', 'in_review', 'review'].includes(statusKey.toLowerCase());
+  return {
+    key: statusKey,
+    label: statusKey,
+    completionState: isDoneKey ? 'done' : 'not_done',
+    executionState: isActiveKey ? 'active' : 'inactive',
+    isCancelled: statusKey.toLowerCase().includes('cancel')
+  };
+}
+
+export function deriveTaskLifecycleState(
+  task: Task,
+  customDefinitions?: StatusDefinition[],
+  referenceDate: Date = new Date()
+): TaskLifecycleState {
+  const def = resolveStatusDefinition(task.status, customDefinitions);
+  const isDone = def.completionState === 'done';
+  const isActive = def.executionState === 'active';
+  const isCancelled = Boolean(def.isCancelled);
+
+  let isOverdue = false;
+  if (!isDone && task.dueDate) {
+    const due = new Date(task.dueDate);
+    if (!isNaN(due.getTime()) && due < referenceDate) {
+      isOverdue = true;
+    }
+  }
+
+  let isUpcoming = false;
+  if (!isDone && !isActive && task.plannedStartDate) {
+    const plannedStart = new Date(task.plannedStartDate);
+    if (!isNaN(plannedStart.getTime()) && plannedStart > referenceDate) {
+      isUpcoming = true;
+    }
+  }
+
+  return {
+    completionState: def.completionState,
+    executionState: def.executionState,
+    isDone,
+    isActive,
+    isCancelled,
+    isOverdue,
+    isUpcoming
+  };
+}

package/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.test.ts","./src/index.ts","./src/engine/index.ts","./src/plugins/index.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"],"version":"5.9.3"}
+{"root":["./src/index.test.ts","./src/index.ts","./src/engine/index.ts","./src/plugins/index.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/index.ts","./src/utils/key.test.ts","./src/utils/key.ts","./src/utils/status.ts"],"version":"5.9.3"}