@nahisaho/musubix-pattern-mcp 3.0.16 → 3.1.0

package/dist/index.d.ts

@@ -10,4 +10,5 @@ export * from './compression/index.js';
 export * from './library/index.js';
 export * from './privacy/index.js';
 export * from './learning/index.js';
+export * from './patterns/concurrency/index.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,YAAY,CAAC;AAG3B,cAAc,sBAAsB,CAAC;AAGrC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAGH,cAAc,YAAY,CAAC;AAG3B,cAAc,sBAAsB,CAAC;AAGrC,cAAc,wBAAwB,CAAC;AAGvC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,qBAAqB,CAAC;AAGpC,cAAc,iCAAiC,CAAC"}

package/dist/index.js

@@ -16,4 +16,6 @@ export * from './library/index.js';
 export * from './privacy/index.js';
 // Wake-Sleep Learning (TSK-WAKE-002)
 export * from './learning/index.js';
+// Concurrency Patterns (TSK-PAT-001, REQ-PAT-001)
+export * from './patterns/concurrency/index.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,QAAQ;AACR,cAAc,YAAY,CAAC;AAE3B,uCAAuC;AACvC,cAAc,sBAAsB,CAAC;AAErC,wCAAwC;AACxC,cAAc,wBAAwB,CAAC;AAEvC,oCAAoC;AACpC,cAAc,oBAAoB,CAAC;AAEnC,uCAAuC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,qCAAqC;AACrC,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,QAAQ;AACR,cAAc,YAAY,CAAC;AAE3B,uCAAuC;AACvC,cAAc,sBAAsB,CAAC;AAErC,wCAAwC;AACxC,cAAc,wBAAwB,CAAC;AAEvC,oCAAoC;AACpC,cAAc,oBAAoB,CAAC;AAEnC,uCAAuC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,qCAAqC;AACrC,cAAc,qBAAqB,CAAC;AAEpC,kDAAkD;AAClD,cAAc,iCAAiC,CAAC"}

package/dist/patterns/concurrency/index.d.ts

@@ -0,0 +1,76 @@
+/**
+ * Concurrency Patterns - Best Practices for Concurrent Operations
+ *
+ * @packageDocumentation
+ * @module patterns/concurrency
+ *
+ * @see REQ-PAT-001 - 同時実行パターン追加
+ * @see TSK-PAT-001 - 同時実行パターンタスク
+ */
+/**
+ * Concurrency pattern definition
+ */
+export interface ConcurrencyPattern {
+    /** Pattern ID */
+    id: string;
+    /** Pattern name */
+    name: string;
+    /** Short description */
+    description: string;
+    /** When to use this pattern */
+    useCase: string;
+    /** When NOT to use this pattern */
+    antiPattern?: string;
+    /** TypeScript template code */
+    template: string;
+    /** Usage example */
+    example: string;
+    /** Related patterns */
+    relatedPatterns: string[];
+    /** Tags for categorization */
+    tags: string[];
+    /** Confidence score (0-1) */
+    confidence: number;
+}
+/**
+ * PAT-CONC-001: Optimistic Locking Pattern
+ *
+ * Use when: Multiple users may edit the same resource,
+ * but conflicts are rare.
+ */
+export declare const OPTIMISTIC_LOCKING: ConcurrencyPattern;
+/**
+ * PAT-CONC-002: Pessimistic Locking Pattern
+ *
+ * Use when: Conflicts are frequent and you need to prevent them entirely.
+ */
+export declare const PESSIMISTIC_LOCKING: ConcurrencyPattern;
+/**
+ * PAT-CONC-003: Hold Pattern
+ *
+ * Use when: You need to temporarily reserve resources before confirmation.
+ */
+export declare const HOLD_PATTERN: ConcurrencyPattern;
+/**
+ * PAT-CONC-004: Idempotency Key Pattern
+ *
+ * Use when: Operations may be retried (network failures, user double-clicks).
+ */
+export declare const IDEMPOTENCY_KEY: ConcurrencyPattern;
+/**
+ * All concurrency patterns
+ */
+export declare const CONCURRENCY_PATTERNS: ConcurrencyPattern[];
+/**
+ * Get pattern by ID
+ */
+export declare function getConcurrencyPattern(id: string): ConcurrencyPattern | undefined;
+/**
+ * Get patterns by tag
+ */
+export declare function getConcurrencyPatternsByTag(tag: string): ConcurrencyPattern[];
+/**
+ * Get all concurrency pattern IDs
+ */
+export declare function getConcurrencyPatternIds(): string[];
+//# sourceMappingURL=index.d.ts.map

package/dist/patterns/concurrency/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patterns/concurrency/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,iBAAiB;IACjB,EAAE,EAAE,MAAM,CAAC;IACX,mBAAmB;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,wBAAwB;IACxB,WAAW,EAAE,MAAM,CAAC;IACpB,+BAA+B;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,mCAAmC;IACnC,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,oBAAoB;IACpB,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,8BAA8B;IAC9B,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,kBAAkB,EAAE,kBA6EhC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,EAAE,kBAmFjC,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,YAAY,EAAE,kBA+F1B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,kBA4G7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,oBAAoB,EAAE,kBAAkB,EAKpD,CAAC;AAEF;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,EAAE,EAAE,MAAM,GAAG,kBAAkB,GAAG,SAAS,CAEhF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,MAAM,GAAG,kBAAkB,EAAE,CAE7E;AAED;;GAEG;AACH,wBAAgB,wBAAwB,IAAI,MAAM,EAAE,CAEnD"}

package/dist/patterns/concurrency/index.js

@@ -0,0 +1,413 @@
+/**
+ * Concurrency Patterns - Best Practices for Concurrent Operations
+ *
+ * @packageDocumentation
+ * @module patterns/concurrency
+ *
+ * @see REQ-PAT-001 - 同時実行パターン追加
+ * @see TSK-PAT-001 - 同時実行パターンタスク
+ */
+/**
+ * PAT-CONC-001: Optimistic Locking Pattern
+ *
+ * Use when: Multiple users may edit the same resource,
+ * but conflicts are rare.
+ */
+export const OPTIMISTIC_LOCKING = {
+    id: 'PAT-CONC-001',
+    name: 'Optimistic Locking',
+    description: 'Allows concurrent reads while detecting conflicts at write time using a version field.',
+    useCase: 'Use when conflicts are rare and you want to maximize read concurrency. Good for high-read, low-write scenarios.',
+    antiPattern: 'Avoid when conflicts are frequent, as users will face many retry prompts.',
+    template: `
+interface WithVersion {
+  version: number;
+}
+
+interface OptimisticLockError extends Error {
+  code: 'OPTIMISTIC_LOCK_ERROR';
+  currentVersion: number;
+  providedVersion: number;
+}
+
+async function updateWithOptimisticLock<T extends WithVersion>(
+  id: string,
+  updates: Partial<T>,
+  expectedVersion: number,
+  repository: {
+    findById(id: string): Promise<T | null>;
+    save(entity: T): Promise<T>;
+  }
+): Promise<Result<T, OptimisticLockError>> {
+  const current = await repository.findById(id);
+  
+  if (!current) {
+    return err({ code: 'NOT_FOUND' } as any);
+  }
+  
+  if (current.version !== expectedVersion) {
+    return err({
+      code: 'OPTIMISTIC_LOCK_ERROR',
+      message: \`Version conflict: expected \${expectedVersion}, found \${current.version}\`,
+      currentVersion: current.version,
+      providedVersion: expectedVersion,
+    } as OptimisticLockError);
+  }
+  
+  const updated = {
+    ...current,
+    ...updates,
+    version: current.version + 1,
+  };
+  
+  return ok(await repository.save(updated));
+}
+`.trim(),
+    example: `
+// Entity with version field
+interface Order extends WithVersion {
+  id: string;
+  status: OrderStatus;
+  version: number;
+}
+
+// Update with optimistic lock
+const result = await updateWithOptimisticLock(
+  orderId,
+  { status: 'completed' },
+  order.version,
+  orderRepository
+);
+
+if (result.isErr() && result.error.code === 'OPTIMISTIC_LOCK_ERROR') {
+  // Handle conflict - reload and retry or notify user
+  console.log('Order was modified by another user');
+}
+`.trim(),
+    relatedPatterns: ['PAT-CONC-002', 'PAT-DESIGN-004'],
+    tags: ['concurrency', 'versioning', 'conflict-detection'],
+    confidence: 0.95,
+};
+/**
+ * PAT-CONC-002: Pessimistic Locking Pattern
+ *
+ * Use when: Conflicts are frequent and you need to prevent them entirely.
+ */
+export const PESSIMISTIC_LOCKING = {
+    id: 'PAT-CONC-002',
+    name: 'Pessimistic Locking',
+    description: 'Acquires exclusive lock before modification, preventing concurrent access.',
+    useCase: 'Use when conflicts are frequent or the cost of conflict resolution is high. Good for financial transactions.',
+    antiPattern: 'Avoid for high-concurrency read scenarios as it reduces throughput.',
+    template: `
+interface Lock {
+  resourceId: string;
+  ownerId: string;
+  acquiredAt: Date;
+  expiresAt: Date;
+}
+
+interface LockManager {
+  acquire(resourceId: string, ownerId: string, ttlMs: number): Promise<Lock | null>;
+  release(resourceId: string, ownerId: string): Promise<boolean>;
+  isLocked(resourceId: string): Promise<boolean>;
+}
+
+async function withPessimisticLock<T>(
+  resourceId: string,
+  ownerId: string,
+  lockManager: LockManager,
+  operation: () => Promise<T>,
+  options: { ttlMs?: number; retryCount?: number; retryDelayMs?: number } = {}
+): Promise<Result<T, 'LOCK_FAILED' | 'OPERATION_FAILED'>> {
+  const { ttlMs = 30000, retryCount = 3, retryDelayMs = 100 } = options;
+  
+  let lock: Lock | null = null;
+  let attempts = 0;
+  
+  while (!lock && attempts < retryCount) {
+    lock = await lockManager.acquire(resourceId, ownerId, ttlMs);
+    if (!lock) {
+      attempts++;
+      await sleep(retryDelayMs * attempts);
+    }
+  }
+  
+  if (!lock) {
+    return err('LOCK_FAILED');
+  }
+  
+  try {
+    const result = await operation();
+    return ok(result);
+  } finally {
+    await lockManager.release(resourceId, ownerId);
+  }
+}
+
+function sleep(ms: number): Promise<void> {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+`.trim(),
+    example: `
+// Transfer money with pessimistic lock
+const result = await withPessimisticLock(
+  \`account:\${fromAccountId}\`,
+  transactionId,
+  lockManager,
+  async () => {
+    const from = await accountRepo.findById(fromAccountId);
+    const to = await accountRepo.findById(toAccountId);
+    
+    from.balance -= amount;
+    to.balance += amount;
+    
+    await accountRepo.save(from);
+    await accountRepo.save(to);
+    
+    return { from, to };
+  },
+  { ttlMs: 5000 }
+);
+`.trim(),
+    relatedPatterns: ['PAT-CONC-001', 'PAT-CONC-003'],
+    tags: ['concurrency', 'locking', 'exclusive-access'],
+    confidence: 0.90,
+};
+/**
+ * PAT-CONC-003: Hold Pattern
+ *
+ * Use when: You need to temporarily reserve resources before confirmation.
+ */
+export const HOLD_PATTERN = {
+    id: 'PAT-CONC-003',
+    name: 'Hold Pattern',
+    description: 'Temporarily reserves a resource with automatic expiry, useful for booking/checkout flows.',
+    useCase: 'Use for e-commerce checkout, seat reservations, or any scenario where users need time to complete a multi-step process.',
+    antiPattern: 'Avoid for instant operations where reservation overhead is unnecessary.',
+    template: `
+interface Hold<T> {
+  id: string;
+  resourceId: string;
+  resourceType: string;
+  heldBy: string;
+  heldData: T;
+  createdAt: Date;
+  expiresAt: Date;
+  status: 'active' | 'confirmed' | 'expired' | 'released';
+}
+
+interface HoldManager<T> {
+  createHold(resourceId: string, data: T, ttlMs: number): Promise<Hold<T>>;
+  confirmHold(holdId: string): Promise<T | null>;
+  releaseHold(holdId: string): Promise<boolean>;
+  getHold(holdId: string): Promise<Hold<T> | null>;
+  cleanupExpired(): Promise<number>;
+}
+
+function createHoldManager<T>(
+  repository: HoldRepository<T>
+): HoldManager<T> {
+  return {
+    async createHold(resourceId, data, ttlMs) {
+      const hold: Hold<T> = {
+        id: generateId(),
+        resourceId,
+        resourceType: typeof data,
+        heldBy: getCurrentUserId(),
+        heldData: data,
+        createdAt: new Date(),
+        expiresAt: new Date(Date.now() + ttlMs),
+        status: 'active',
+      };
+      return repository.save(hold);
+    },
+    
+    async confirmHold(holdId) {
+      const hold = await repository.findById(holdId);
+      if (!hold || hold.status !== 'active') return null;
+      if (hold.expiresAt < new Date()) {
+        await repository.updateStatus(holdId, 'expired');
+        return null;
+      }
+      await repository.updateStatus(holdId, 'confirmed');
+      return hold.heldData;
+    },
+    
+    async releaseHold(holdId) {
+      return repository.updateStatus(holdId, 'released');
+    },
+    
+    async getHold(holdId) {
+      return repository.findById(holdId);
+    },
+    
+    async cleanupExpired() {
+      return repository.markExpired(new Date());
+    },
+  };
+}
+`.trim(),
+    example: `
+// E-commerce checkout flow
+const holdManager = createHoldManager<CartItem[]>(holdRepository);
+
+// Step 1: User adds items to cart - create hold
+const hold = await holdManager.createHold(
+  'cart:' + cartId,
+  cartItems,
+  15 * 60 * 1000 // 15 minutes
+);
+
+// Step 2: User completes payment
+const confirmedItems = await holdManager.confirmHold(hold.id);
+if (confirmedItems) {
+  await createOrder(confirmedItems);
+} else {
+  // Hold expired, items may no longer be available
+  throw new Error('Checkout session expired');
+}
+`.trim(),
+    relatedPatterns: ['PAT-CONC-002', 'PAT-DESIGN-007'],
+    tags: ['concurrency', 'reservation', 'expiry', 'checkout'],
+    confidence: 0.90,
+};
+/**
+ * PAT-CONC-004: Idempotency Key Pattern
+ *
+ * Use when: Operations may be retried (network failures, user double-clicks).
+ */
+export const IDEMPOTENCY_KEY = {
+    id: 'PAT-CONC-004',
+    name: 'Idempotency Key',
+    description: 'Ensures operations are processed exactly once using a client-provided unique key.',
+    useCase: 'Use for payment processing, order creation, or any operation that should not be duplicated on retry.',
+    antiPattern: 'Not needed for naturally idempotent operations (like GET requests or updates that set absolute values).',
+    template: `
+interface IdempotencyRecord<T> {
+  key: string;
+  requestHash: string;
+  status: 'processing' | 'completed' | 'failed';
+  result?: T;
+  error?: string;
+  createdAt: Date;
+  expiresAt: Date;
+}
+
+interface IdempotencyStore<T> {
+  get(key: string): Promise<IdempotencyRecord<T> | null>;
+  create(key: string, requestHash: string, ttlMs: number): Promise<boolean>;
+  complete(key: string, result: T): Promise<void>;
+  fail(key: string, error: string): Promise<void>;
+}
+
+async function withIdempotency<T>(
+  idempotencyKey: string,
+  requestBody: unknown,
+  store: IdempotencyStore<T>,
+  operation: () => Promise<T>,
+  options: { ttlMs?: number } = {}
+): Promise<Result<T, 'IN_PROGRESS' | 'REQUEST_MISMATCH'>> {
+  const { ttlMs = 24 * 60 * 60 * 1000 } = options; // 24 hours default
+  const requestHash = hashRequest(requestBody);
+  
+  // Check for existing record
+  const existing = await store.get(idempotencyKey);
+  
+  if (existing) {
+    // Verify request body matches
+    if (existing.requestHash !== requestHash) {
+      return err('REQUEST_MISMATCH');
+    }
+    
+    // Return cached result if completed
+    if (existing.status === 'completed' && existing.result !== undefined) {
+      return ok(existing.result);
+    }
+    
+    // Still processing
+    if (existing.status === 'processing') {
+      return err('IN_PROGRESS');
+    }
+  }
+  
+  // Create new record
+  const created = await store.create(idempotencyKey, requestHash, ttlMs);
+  if (!created) {
+    return err('IN_PROGRESS'); // Race condition - another request got there first
+  }
+  
+  try {
+    const result = await operation();
+    await store.complete(idempotencyKey, result);
+    return ok(result);
+  } catch (error) {
+    await store.fail(idempotencyKey, String(error));
+    throw error;
+  }
+}
+
+function hashRequest(body: unknown): string {
+  return JSON.stringify(body); // Simplified - use crypto hash in production
+}
+`.trim(),
+    example: `
+// Payment processing with idempotency
+app.post('/payments', async (req, res) => {
+  const idempotencyKey = req.headers['idempotency-key'];
+  
+  if (!idempotencyKey) {
+    return res.status(400).json({ error: 'Idempotency-Key header required' });
+  }
+  
+  const result = await withIdempotency(
+    idempotencyKey,
+    req.body,
+    idempotencyStore,
+    async () => {
+      return await paymentService.processPayment(req.body);
+    }
+  );
+  
+  if (result.isErr()) {
+    if (result.error === 'IN_PROGRESS') {
+      return res.status(409).json({ error: 'Request in progress' });
+    }
+    return res.status(422).json({ error: 'Request body mismatch' });
+  }
+  
+  return res.json(result.value);
+});
+`.trim(),
+    relatedPatterns: ['PAT-CONC-001', 'PAT-DESIGN-005'],
+    tags: ['concurrency', 'idempotency', 'retry-safety', 'payment'],
+    confidence: 0.95,
+};
+/**
+ * All concurrency patterns
+ */
+export const CONCURRENCY_PATTERNS = [
+    OPTIMISTIC_LOCKING,
+    PESSIMISTIC_LOCKING,
+    HOLD_PATTERN,
+    IDEMPOTENCY_KEY,
+];
+/**
+ * Get pattern by ID
+ */
+export function getConcurrencyPattern(id) {
+    return CONCURRENCY_PATTERNS.find((p) => p.id === id);
+}
+/**
+ * Get patterns by tag
+ */
+export function getConcurrencyPatternsByTag(tag) {
+    return CONCURRENCY_PATTERNS.filter((p) => p.tags.includes(tag));
+}
+/**
+ * Get all concurrency pattern IDs
+ */
+export function getConcurrencyPatternIds() {
+    return CONCURRENCY_PATTERNS.map((p) => p.id);
+}
+//# sourceMappingURL=index.js.map

package/dist/patterns/concurrency/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/patterns/concurrency/index.ts"],"names":[],"mappings":"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"}

package/dist/patterns/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Patterns Index
+ *
+ * Exports all design patterns from submodules.
+ *
+ * @packageDocumentation
+ * @module patterns
+ */
+export * from './concurrency/index.js';
+export * from './time/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/patterns/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/patterns/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC"}

package/dist/patterns/index.js

@@ -0,0 +1,11 @@
+/**
+ * Patterns Index
+ *
+ * Exports all design patterns from submodules.
+ *
+ * @packageDocumentation
+ * @module patterns
+ */
+export * from './concurrency/index.js';
+export * from './time/index.js';
+//# sourceMappingURL=index.js.map

package/dist/patterns/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/patterns/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,cAAc,wBAAwB,CAAC;AACvC,cAAc,iBAAiB,CAAC"}

package/dist/patterns/time/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Time Constraint Patterns
+ *
+ * Best practice patterns for time-based operations.
+ *
+ * @packageDocumentation
+ * @module patterns/time
+ *
+ * @see BP-DESIGN-007 - Expiry Time Logic
+ * @see TSK-PAT-002 - 時間制約パターン
+ */
+import type { DesignPattern, PatternExample } from '../../types.js';
+/**
+ * PAT-TIME-001: Expiry Pattern
+ *
+ * Manages entities with expiration times.
+ */
+export declare const EXPIRY_PATTERN: DesignPattern;
+/**
+ * PAT-TIME-002: Scheduled Event Pattern
+ *
+ * Handles events that occur at specific times.
+ */
+export declare const SCHEDULED_PATTERN: DesignPattern;
+/**
+ * PAT-TIME-003: Interval Pattern
+ *
+ * Manages recurring events at fixed intervals.
+ */
+export declare const INTERVAL_PATTERN: DesignPattern;
+/**
+ * PAT-TIME-004: Streak Pattern
+ *
+ * Tracks consecutive activity streaks.
+ */
+export declare const STREAK_PATTERN: DesignPattern;
+/**
+ * PAT-TIME-005: Cooldown Pattern
+ *
+ * Prevents actions from being repeated too quickly.
+ */
+export declare const COOLDOWN_PATTERN: DesignPattern;
+/**
+ * All time constraint patterns
+ */
+export declare const TIME_PATTERNS: DesignPattern[];
+/**
+ * Get a time pattern by ID
+ */
+export declare function getTimePattern(id: string): DesignPattern | undefined;
+/**
+ * Get patterns applicable to a domain
+ */
+export declare function getTimePatternsByDomain(domain: string): DesignPattern[];
+/**
+ * Pattern examples for time patterns
+ */
+export declare const TIME_PATTERN_EXAMPLES: PatternExample[];
+//# sourceMappingURL=index.d.ts.map

package/dist/patterns/time/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/patterns/time/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,KAAK,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAEpE;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,aAyC5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,EAAE,aA6C/B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,aAiD9B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,cAAc,EAAE,aAyE5B,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,EAAE,aA2D9B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,aAAa,EAAE,aAAa,EAMxC,CAAC;AAEF;;GAEG;AACH,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,SAAS,CAEpE;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,MAAM,GAAG,aAAa,EAAE,CAIvE;AAED;;GAEG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,EA0CjD,CAAC"}

package/dist/patterns/time/index.js

@@ -0,0 +1,362 @@
+/**
+ * Time Constraint Patterns
+ *
+ * Best practice patterns for time-based operations.
+ *
+ * @packageDocumentation
+ * @module patterns/time
+ *
+ * @see BP-DESIGN-007 - Expiry Time Logic
+ * @see TSK-PAT-002 - 時間制約パターン
+ */
+/**
+ * PAT-TIME-001: Expiry Pattern
+ *
+ * Manages entities with expiration times.
+ */
+export const EXPIRY_PATTERN = {
+    id: 'PAT-TIME-001',
+    name: 'Expiry Pattern',
+    category: 'temporal',
+    domain: ['all'],
+    description: 'Manages entities with explicit expiration times. Use expiresAt field to track validity.',
+    problem: 'Entities need to become invalid after a certain time (e.g., tokens, coupons, sessions).',
+    solution: 'Store expiresAt as a Date field. Provide isExpired() method that compares against current time.',
+    applicability: [
+        'Tokens and sessions',
+        'Coupons and promotions',
+        'Temporary access',
+        'Cache entries',
+    ],
+    consequences: {
+        positive: [
+            'Clear expiration semantics',
+            'Easy to query expired entities',
+            'Timezone-safe with UTC',
+        ],
+        negative: [
+            'Requires periodic cleanup jobs',
+            'Clock synchronization needed for distributed systems',
+        ],
+    },
+    implementation: `interface Expirable {
+  readonly expiresAt: Date;
+}
+
+function isExpired(entity: Expirable, now: Date = new Date()): boolean {
+  return entity.expiresAt <= now;
+}
+
+function createExpiry(durationMs: number, from: Date = new Date()): Date {
+  return new Date(from.getTime() + durationMs);
+}`,
+    relatedPatterns: ['PAT-TIME-002', 'PAT-TIME-003'],
+    confidence: 0.9,
+};
+/**
+ * PAT-TIME-002: Scheduled Event Pattern
+ *
+ * Handles events that occur at specific times.
+ */
+export const SCHEDULED_PATTERN = {
+    id: 'PAT-TIME-002',
+    name: 'Scheduled Event Pattern',
+    category: 'temporal',
+    domain: ['all'],
+    description: 'Manages events scheduled for future execution at specific times.',
+    problem: 'Need to execute actions at predetermined times (e.g., reminders, appointments).',
+    solution: 'Store scheduledAt timestamp. Use job queue to trigger actions when time arrives.',
+    applicability: [
+        'Appointment systems',
+        'Reminder notifications',
+        'Scheduled publishing',
+        'Delayed tasks',
+    ],
+    consequences: {
+        positive: [
+            'Predictable execution timing',
+            'Supports multiple time zones',
+            'Can reschedule easily',
+        ],
+        negative: [
+            'Requires reliable scheduler',
+            'Missed events need handling strategy',
+        ],
+    },
+    implementation: `interface Schedulable {
+  readonly scheduledAt: Date;
+  readonly status: 'pending' | 'executed' | 'cancelled';
+}
+
+function isReady(event: Schedulable, now: Date = new Date()): boolean {
+  return event.status === 'pending' && event.scheduledAt <= now;
+}
+
+function reschedule(event: Schedulable, newTime: Date): Schedulable {
+  if (event.status !== 'pending') {
+    throw new Error('Cannot reschedule non-pending event');
+  }
+  return { ...event, scheduledAt: newTime };
+}`,
+    relatedPatterns: ['PAT-TIME-001', 'PAT-TIME-003'],
+    confidence: 0.85,
+};
+/**
+ * PAT-TIME-003: Interval Pattern
+ *
+ * Manages recurring events at fixed intervals.
+ */
+export const INTERVAL_PATTERN = {
+    id: 'PAT-TIME-003',
+    name: 'Interval Pattern',
+    category: 'temporal',
+    domain: ['all'],
+    description: 'Manages recurring events that happen at fixed intervals.',
+    problem: 'Events need to repeat periodically (e.g., subscriptions, polling, cron jobs).',
+    solution: 'Store intervalMs and lastRunAt. Calculate nextRunAt from last execution.',
+    applicability: [
+        'Subscription billing',
+        'Recurring tasks',
+        'Health checks',
+        'Data synchronization',
+    ],
+    consequences: {
+        positive: [
+            'Consistent timing',
+            'Easy to adjust frequency',
+            'Tracks execution history',
+        ],
+        negative: [
+            'Drift accumulation if not anchored',
+            'Overlapping executions need handling',
+        ],
+    },
+    implementation: `interface Recurring {
+  readonly intervalMs: number;
+  readonly lastRunAt: Date | null;
+  readonly anchorTime: Date;
+}
+
+function getNextRunAt(recurring: Recurring, now: Date = new Date()): Date {
+  if (!recurring.lastRunAt) {
+    return recurring.anchorTime;
+  }
+  const elapsed = now.getTime() - recurring.anchorTime.getTime();
+  const periods = Math.floor(elapsed / recurring.intervalMs) + 1;
+  return new Date(recurring.anchorTime.getTime() + periods * recurring.intervalMs);
+}
+
+function isDue(recurring: Recurring, now: Date = new Date()): boolean {
+  const next = getNextRunAt(recurring, now);
+  return next <= now;
+}`,
+    relatedPatterns: ['PAT-TIME-001', 'PAT-TIME-002', 'PAT-TIME-004'],
+    confidence: 0.85,
+};
+/**
+ * PAT-TIME-004: Streak Pattern
+ *
+ * Tracks consecutive activity streaks.
+ */
+export const STREAK_PATTERN = {
+    id: 'PAT-TIME-004',
+    name: 'Streak Pattern',
+    category: 'temporal',
+    domain: ['fitness', 'education', 'gaming'],
+    description: 'Tracks consecutive day/activity streaks with grace period support.',
+    problem: 'Need to track user engagement through consecutive activity days (e.g., login streaks, workout streaks).',
+    solution: 'Store currentStreak, longestStreak, lastActivityAt. Update on each activity with grace period.',
+    applicability: [
+        'Gamification features',
+        'Habit tracking',
+        'User engagement metrics',
+        'Loyalty programs',
+    ],
+    consequences: {
+        positive: [
+            'Motivates consistent engagement',
+            'Clear progress tracking',
+            'Supports grace periods',
+        ],
+        negative: [
+            'Timezone handling complexity',
+            'Grace period edge cases',
+        ],
+    },
+    implementation: `interface Streak {
+  currentStreak: number;
+  longestStreak: number;
+  lastActivityAt: Date | null;
+}
+
+const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+
+function recordActivity(
+  streak: Streak,
+  gracePeriodMs: number = ONE_DAY_MS * 1.5,
+  now: Date = new Date()
+): Streak {
+  if (!streak.lastActivityAt) {
+    return {
+      currentStreak: 1,
+      longestStreak: Math.max(1, streak.longestStreak),
+      lastActivityAt: now,
+    };
+  }
+
+  const elapsed = now.getTime() - streak.lastActivityAt.getTime();
+
+  if (elapsed < ONE_DAY_MS) {
+    // Same day, no change
+    return streak;
+  } else if (elapsed <= gracePeriodMs) {
+    // Within grace period, increment streak
+    const newCurrent = streak.currentStreak + 1;
+    return {
+      currentStreak: newCurrent,
+      longestStreak: Math.max(newCurrent, streak.longestStreak),
+      lastActivityAt: now,
+    };
+  } else {
+    // Streak broken
+    return {
+      currentStreak: 1,
+      longestStreak: streak.longestStreak,
+      lastActivityAt: now,
+    };
+  }
+}`,
+    relatedPatterns: ['PAT-TIME-003'],
+    confidence: 0.8,
+};
+/**
+ * PAT-TIME-005: Cooldown Pattern
+ *
+ * Prevents actions from being repeated too quickly.
+ */
+export const COOLDOWN_PATTERN = {
+    id: 'PAT-TIME-005',
+    name: 'Cooldown Pattern',
+    category: 'temporal',
+    domain: ['all'],
+    description: 'Prevents actions from being performed too frequently with a cooldown period.',
+    problem: 'Need to rate-limit user actions (e.g., password reset, notifications, API calls).',
+    solution: 'Track lastActionAt and cooldownMs. Check if enough time has passed before allowing action.',
+    applicability: [
+        'Rate limiting',
+        'Spam prevention',
+        'Resource protection',
+        'Gaming abilities',
+    ],
+    consequences: {
+        positive: [
+            'Prevents abuse',
+            'Fair resource distribution',
+            'Simple implementation',
+        ],
+        negative: [
+            'May frustrate legitimate users',
+            'Clock skew issues in distributed systems',
+        ],
+    },
+    implementation: `interface Cooldownable {
+  readonly lastActionAt: Date | null;
+  readonly cooldownMs: number;
+}
+
+function canPerformAction(
+  item: Cooldownable,
+  now: Date = new Date()
+): { allowed: boolean; remainingMs: number } {
+  if (!item.lastActionAt) {
+    return { allowed: true, remainingMs: 0 };
+  }
+
+  const elapsed = now.getTime() - item.lastActionAt.getTime();
+  const remaining = item.cooldownMs - elapsed;
+
+  return {
+    allowed: remaining <= 0,
+    remainingMs: Math.max(0, remaining),
+  };
+}
+
+function performAction(item: Cooldownable, now: Date = new Date()): Cooldownable {
+  const check = canPerformAction(item, now);
+  if (!check.allowed) {
+    throw new Error(\`Action on cooldown. Wait \${check.remainingMs}ms\`);
+  }
+  return { ...item, lastActionAt: now };
+}`,
+    relatedPatterns: ['PAT-TIME-001', 'PAT-CONC-004'],
+    confidence: 0.85,
+};
+/**
+ * All time constraint patterns
+ */
+export const TIME_PATTERNS = [
+    EXPIRY_PATTERN,
+    SCHEDULED_PATTERN,
+    INTERVAL_PATTERN,
+    STREAK_PATTERN,
+    COOLDOWN_PATTERN,
+];
+/**
+ * Get a time pattern by ID
+ */
+export function getTimePattern(id) {
+    return TIME_PATTERNS.find((p) => p.id === id);
+}
+/**
+ * Get patterns applicable to a domain
+ */
+export function getTimePatternsByDomain(domain) {
+    return TIME_PATTERNS.filter((p) => p.domain.includes('all') || p.domain.includes(domain));
+}
+/**
+ * Pattern examples for time patterns
+ */
+export const TIME_PATTERN_EXAMPLES = [
+    {
+        patternId: 'PAT-TIME-001',
+        scenario: 'クーポンの有効期限管理',
+        code: `const coupon = {
+  code: 'SUMMER2025',
+  discount: 20,
+  expiresAt: new Date('2025-08-31T23:59:59Z'),
+};
+
+if (isExpired(coupon)) {
+  throw new Error('このクーポンは有効期限切れです');
+}`,
+        domain: 'ecommerce',
+    },
+    {
+        patternId: 'PAT-TIME-002',
+        scenario: '予約のスケジュール管理',
+        code: `const appointment = {
+  id: 'APT-001',
+  scheduledAt: new Date('2025-01-20T10:00:00Z'),
+  status: 'pending' as const,
+};
+
+if (isReady(appointment)) {
+  sendReminder(appointment);
+}`,
+        domain: 'healthcare',
+    },
+    {
+        patternId: 'PAT-TIME-004',
+        scenario: 'フィットネスアプリの連続記録',
+        code: `let streak: Streak = {
+  currentStreak: 5,
+  longestStreak: 10,
+  lastActivityAt: new Date('2025-01-18'),
+};
+
+streak = recordActivity(streak);
+console.log(\`現在の連続: \${streak.currentStreak}日\`);`,
+        domain: 'fitness',
+    },
+];
+//# sourceMappingURL=index.js.map

package/dist/patterns/time/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/patterns/time/index.ts"],"names":[],"mappings":"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"}

package/dist/types.d.ts

@@ -86,4 +86,49 @@ export interface PrivacyFilterResult {
     reason?: string;
     sanitizedPattern?: Pattern;
 }
+/**
+ * Design Pattern - Best practice pattern definition
+ */
+export interface DesignPattern {
+    /** Unique pattern ID (e.g., PAT-CONC-001, PAT-TIME-001) */
+    id: string;
+    /** Human-readable name */
+    name: string;
+    /** Pattern category (concurrency, temporal, etc.) */
+    category: string;
+    /** Applicable domains */
+    domain: string[];
+    /** Brief description */
+    description: string;
+    /** Problem this pattern solves */
+    problem: string;
+    /** Solution approach */
+    solution: string;
+    /** When to apply this pattern */
+    applicability: string[];
+    /** Trade-offs */
+    consequences: {
+        positive: string[];
+        negative: string[];
+    };
+    /** TypeScript implementation example */
+    implementation: string;
+    /** Related pattern IDs */
+    relatedPatterns?: string[];
+    /** Confidence score (0-1) */
+    confidence: number;
+}
+/**
+ * Pattern Example - Concrete usage example
+ */
+export interface PatternExample {
+    /** Pattern ID this example demonstrates */
+    patternId: string;
+    /** Scenario description */
+    scenario: string;
+    /** Example code */
+    code: string;
+    /** Domain this example applies to */
+    domain: string;
+}
 //# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,EAAE,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,aAAa,EAAE,QAAQ,CAAC;IACxB,WAAW,EAAE,QAAQ,CAAC;CACvB;AAED,MAAM,WAAW,QAAQ;IACvB,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,GAAG,EAAE,OAAO,CAAC;IACb,KAAK,EAAE,WAAW,EAAE,CAAC;IACrB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;IACX,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,mBAAmB,EAAE,OAAO,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,iBAAiB;IAChC,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,CAAC;IACjB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,QAAQ,GAAG,SAAS,GAAG,YAAY,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,UAAU,EAAE,MAAM,EAAE,CAAC;IACrB,MAAM,EAAE,MAAM,EAAE,EAAE,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,EAAE,EAAE,MAAM,CAAC;IACX,QAAQ,EAAE,OAAO,CAAC;IAClB,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,gBAAgB,CAAC,EAAE,OAAO,CAAC;CAC5B"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nahisaho/musubix-pattern-mcp",
-  "version": "3.0.16",
+  "version": "3.1.0",
   "description": "MUSUBIX Pattern Library Learning MCP - AST-based pattern extraction and abstraction",
   "type": "module",
   "main": "./dist/index.js",