@useody/detectors 0.0.1

package/dist/helpers/llm-timeout.js

@@ -0,0 +1,30 @@
+const DEFAULT_TIMEOUT_MS = 15_000;
+/** Check whether an error is an unrecoverable auth/quota failure. */
+function isFatalLlmError(err) {
+    if (!(err instanceof Error))
+        return false;
+    return err.name === 'LLMAuthError'
+        || err.message.includes('authentication/quota error')
+        || err.message.includes('Invalid API key');
+}
+/**
+ * Call LLM with a timeout.
+ * Returns empty string on transient failures (timeout, 5xx).
+ * Re-throws fatal errors (401, 403) so the scan can fail fast.
+ */
+export async function completeWithTimeout(llm, messages, options, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    try {
+        return await Promise.race([
+            llm.complete(messages, options),
+            new Promise((_, reject) => {
+                setTimeout(() => reject(new Error('LLM request timed out')), timeoutMs);
+            }),
+        ]);
+    }
+    catch (err) {
+        if (isFatalLlmError(err))
+            throw err;
+        return '';
+    }
+}
+//# sourceMappingURL=llm-timeout.js.map

package/dist/helpers/text-utils.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Text utility functions for lexical matching in detectors.
+ * Extracted from the undocumented detector.
+ * @module helpers/text-utils
+ */
+/** Stop words filtered out during tokenization. */
+export declare const STOP_WORDS: Set<string>;
+/** Lowercase, remove punctuation, collapse whitespace. */
+export declare function normalize(text: string): string;
+/** Normalize, split, and filter stopwords + short tokens (len < 2). */
+export declare function tokenize(text: string): string[];
+/** Return the intersection of two string arrays. */
+export declare function sharedTokens(a: string[], b: string[]): string[];
+/** Jaccard similarity: intersection / union. Returns 0 for empty inputs. */
+export declare function lexicalScore(a: string[], b: string[]): number;
+/** Build a signal from a title and facts for lexical matching. */
+export declare function buildSignal(title: string, facts: string[]): {
+    titleTokens: string[];
+    tokens: string[];
+};
+//# sourceMappingURL=text-utils.d.ts.map

package/dist/helpers/text-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text-utils.d.ts","sourceRoot":"","sources":["../../src/helpers/text-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,mDAAmD;AACnD,eAAO,MAAM,UAAU,aAoBrB,CAAC;AAEH,0DAA0D;AAC1D,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAM9C;AAED,uEAAuE;AACvE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAI/C;AAED,oDAAoD;AACpD,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAG/D;AAED,4EAA4E;AAC5E,wBAAgB,YAAY,CAAC,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAM7D;AAED,kEAAkE;AAClE,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,KAAK,EAAE,MAAM,EAAE,GACd;IAAE,WAAW,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,CAK7C"}

package/dist/helpers/text-utils.js

@@ -0,0 +1,63 @@
+/**
+ * Text utility functions for lexical matching in detectors.
+ * Extracted from the undocumented detector.
+ * @module helpers/text-utils
+ */
+/** Stop words filtered out during tokenization. */
+export const STOP_WORDS = new Set([
+    'the',
+    'and',
+    'for',
+    'with',
+    'from',
+    'this',
+    'that',
+    'discussion',
+    'update',
+    'changes',
+    'change',
+    'proposal',
+    'announcement',
+    'rollout',
+    'thread',
+    'notes',
+    'week',
+    'month',
+    'new',
+]);
+/** Lowercase, remove punctuation, collapse whitespace. */
+export function normalize(text) {
+    return text
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+}
+/** Normalize, split, and filter stopwords + short tokens (len < 2). */
+export function tokenize(text) {
+    return normalize(text)
+        .split(' ')
+        .filter((token) => token.length >= 2 && !STOP_WORDS.has(token));
+}
+/** Return the intersection of two string arrays. */
+export function sharedTokens(a, b) {
+    const bSet = new Set(b);
+    return [...new Set(a)].filter((token) => bSet.has(token));
+}
+/** Jaccard similarity: intersection / union. Returns 0 for empty inputs. */
+export function lexicalScore(a, b) {
+    const aSet = new Set(a);
+    const bSet = new Set(b);
+    const union = new Set([...aSet, ...bSet]);
+    if (union.size === 0)
+        return 0;
+    return [...aSet].filter((token) => bSet.has(token)).length / union.size;
+}
+/** Build a signal from a title and facts for lexical matching. */
+export function buildSignal(title, facts) {
+    return {
+        titleTokens: tokenize(title),
+        tokens: tokenize(`${title} ${facts.slice(0, 5).join(' ')}`),
+    };
+}
+//# sourceMappingURL=text-utils.js.map

package/dist/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * @ody/detectors — pure function detectors for knowledge graph analysis.
+ * @module @ody/detectors
+ */
+export { detectContradictions } from './contradictions.js';
+export { detectDuplicates } from './duplicates.js';
+export { detectStaleness } from './staleness.js';
+export { detectUndocumented } from './undocumented.js';
+export { detectTimeBombs } from './time-bombs.js';
+export { runDetection } from './run-detection.js';
+export type { RunDetectionInput, RunDetectionOutput, DetectorRunStats, } from './run-detection.js';
+export { analyzeCorpus } from './consultant-analysis.js';
+export { runConsensusAnalysis } from './consensus.js';
+export type { ConsensusOptions } from './consensus.js';
+export { computeDeterministicHealthScore } from './health-score.js';
+export type { FindingCategory, ConsultingFinding, HealthScore, DocumentInfo, AnalysisResult, AnalysisInput, } from './consultant-analysis.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,EAAE,oBAAoB,EAAE,MAAM,qBAAqB,CAAC;AAC3D,OAAO,EAAE,gBAAgB,EAAE,MAAM,iBAAiB,CAAC;AACnD,OAAO,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAC;AACjD,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAClD,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,GACjB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AACzD,OAAO,EAAE,oBAAoB,EAAE,MAAM,gBAAgB,CAAC;AACtD,YAAY,EAAE,gBAAgB,EAAE,MAAM,gBAAgB,CAAC;AACvD,OAAO,EAAE,+BAA+B,EAAE,MAAM,mBAAmB,CAAC;AACpE,YAAY,EACV,eAAe,EACf,iBAAiB,EACjB,WAAW,EACX,YAAY,EACZ,cAAc,EACd,aAAa,GACd,MAAM,0BAA0B,CAAC"}

package/dist/index.js

@@ -0,0 +1,14 @@
+/**
+ * @ody/detectors — pure function detectors for knowledge graph analysis.
+ * @module @ody/detectors
+ */
+export { detectContradictions } from './contradictions.js';
+export { detectDuplicates } from './duplicates.js';
+export { detectStaleness } from './staleness.js';
+export { detectUndocumented } from './undocumented.js';
+export { detectTimeBombs } from './time-bombs.js';
+export { runDetection } from './run-detection.js';
+export { analyzeCorpus } from './consultant-analysis.js';
+export { runConsensusAnalysis } from './consensus.js';
+export { computeDeterministicHealthScore } from './health-score.js';
+//# sourceMappingURL=index.js.map

package/dist/run-detection.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Simple detection orchestrator — runs all five detectors on in-memory arrays.
+ * Use this for library / adapter integration where nodes and edges are
+ * already loaded (no repository or vector index required).
+ * @module run-detection
+ */
+import type { Detection, DetectorFn, KnowledgeEdge, KnowledgeNode, LLMProvider } from '@useody/platform-core';
+export interface RunDetectionInput {
+    nodes: KnowledgeNode[];
+    edges: KnowledgeEdge[];
+    llm?: LLMProvider;
+    detectors?: DetectorFn[];
+    onProgress?: (name: string, status: 'started' | 'completed') => void;
+}
+export interface DetectorRunStats {
+    name: string;
+    detectionCount: number;
+    durationMs: number;
+}
+export interface RunDetectionOutput {
+    detections: Detection[];
+    stats: DetectorRunStats[];
+}
+/**
+ * Run detection across in-memory knowledge nodes and edges.
+ * By default runs all five detectors; pass `detectors` to override.
+ */
+export declare function runDetection(input: RunDetectionInput): Promise<RunDetectionOutput>;
+//# sourceMappingURL=run-detection.d.ts.map

package/dist/run-detection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-detection.d.ts","sourceRoot":"","sources":["../src/run-detection.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EACV,SAAS,EACT,UAAU,EACV,aAAa,EACb,aAAa,EACb,WAAW,EACZ,MAAM,uBAAuB,CAAC;AAO/B,MAAM,WAAW,iBAAiB;IAChC,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,KAAK,EAAE,aAAa,EAAE,CAAC;IACvB,GAAG,CAAC,EAAE,WAAW,CAAC;IAClB,SAAS,CAAC,EAAE,UAAU,EAAE,CAAC;IACzB,UAAU,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,WAAW,KAAK,IAAI,CAAC;CACtE;AAED,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,MAAM,CAAC;IACb,cAAc,EAAE,MAAM,CAAC;IACvB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,SAAS,EAAE,CAAC;IACxB,KAAK,EAAE,gBAAgB,EAAE,CAAC;CAC3B;AAUD;;;GAGG;AACH,wBAAsB,YAAY,CAChC,KAAK,EAAE,iBAAiB,GACvB,OAAO,CAAC,kBAAkB,CAAC,CA6B7B"}

package/dist/run-detection.js

@@ -0,0 +1,46 @@
+import { detectContradictions } from './contradictions.js';
+import { detectDuplicates } from './duplicates.js';
+import { detectStaleness } from './staleness.js';
+import { detectUndocumented } from './undocumented.js';
+import { detectTimeBombs } from './time-bombs.js';
+const DEFAULT_DETECTORS = [
+    detectContradictions,
+    detectDuplicates,
+    detectStaleness,
+    detectUndocumented,
+    detectTimeBombs,
+];
+/**
+ * Run detection across in-memory knowledge nodes and edges.
+ * By default runs all five detectors; pass `detectors` to override.
+ */
+export async function runDetection(input) {
+    const { nodes, edges, llm, onProgress } = input;
+    const detectors = input.detectors ?? DEFAULT_DETECTORS;
+    const allDetections = [];
+    const stats = [];
+    for (const detector of detectors) {
+        const name = detector.name || 'unknown';
+        onProgress?.(name, 'started');
+        const start = Date.now();
+        try {
+            const detections = await detector(nodes, edges, llm);
+            const durationMs = Date.now() - start;
+            allDetections.push(...detections);
+            stats.push({ name, detectionCount: detections.length, durationMs });
+        }
+        catch (err) {
+            const durationMs = Date.now() - start;
+            stats.push({ name, detectionCount: 0, durationMs });
+            // Re-throw fatal errors (auth/quota); skip transient ones
+            if (err instanceof Error && (err.name === 'LLMAuthError'
+                || err.message.includes('authentication/quota error'))) {
+                throw err;
+            }
+            // Transient error — continue with remaining detectors
+        }
+        onProgress?.(name, 'completed');
+    }
+    return { detections: allDetections, stats };
+}
+//# sourceMappingURL=run-detection.js.map

package/dist/staleness.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Staleness detector.
+ * Finds knowledge nodes superseded by newer nodes or with stale date references.
+ * @module staleness
+ */
+import type { DetectorFn } from '@useody/platform-core';
+declare const SIX_MONTHS_MS: number;
+/** Parse a date string like "January 2025" or "2025-01" into a Date. */
+declare function parseDateRef(ref: string): Date | null;
+/** Extract referenced dates from content. */
+declare function extractContentDates(text: string): {
+    label: string;
+    date: Date;
+}[];
+/**
+ * Detect stale knowledge nodes.
+ * Uses supersedes edges and date-based content heuristics.
+ */
+declare const detectStaleness: DetectorFn;
+export { detectStaleness, extractContentDates, parseDateRef, SIX_MONTHS_MS };
+//# sourceMappingURL=staleness.d.ts.map

package/dist/staleness.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"staleness.d.ts","sourceRoot":"","sources":["../src/staleness.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAIV,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAc/B,QAAA,MAAM,aAAa,QAA+B,CAAC;AAEnD,wEAAwE;AACxE,iBAAS,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,CAe9C;AAED,6CAA6C;AAC7C,iBAAS,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAA;CAAE,EAAE,CAY1E;AAED;;;GAGG;AACH,QAAA,MAAM,eAAe,EAAE,UAyFtB,CAAC;AAOF,OAAO,EAAE,eAAe,EAAE,mBAAmB,EAAE,YAAY,EAAE,aAAa,EAAE,CAAC"}

package/dist/staleness.js

@@ -0,0 +1,128 @@
+const LAST_UPDATED_PATTERN = /\b(?:last\s+updated|updated|modified)\s*:?\s*((?:january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{4}|\d{4}-\d{2}(?:-\d{2})?)\b/gi;
+const AS_OF_PATTERN = /\bas\s+of\s+((?:january|february|march|april|may|june|july|august|september|october|november|december)\s+\d{4}|\d{4}-\d{2}(?:-\d{2})?)\b/gi;
+const MONTH_MAP = {
+    january: 0, february: 1, march: 2, april: 3,
+    may: 4, june: 5, july: 6, august: 7,
+    september: 8, october: 9, november: 10, december: 11,
+};
+const SIX_MONTHS_MS = 6 * 30 * 24 * 60 * 60 * 1000;
+/** Parse a date string like "January 2025" or "2025-01" into a Date. */
+function parseDateRef(ref) {
+    const isoMatch = ref.match(/^(\d{4})-(\d{2})(?:-(\d{2}))?$/);
+    if (isoMatch) {
+        const y = parseInt(isoMatch[1], 10);
+        const m = parseInt(isoMatch[2], 10) - 1;
+        const d = isoMatch[3] ? parseInt(isoMatch[3], 10) : 1;
+        return new Date(y, m, d);
+    }
+    const monthMatch = ref.match(/^(january|february|march|april|may|june|july|august|september|october|november|december)\s+(\d{4})$/i);
+    if (monthMatch) {
+        const m = MONTH_MAP[monthMatch[1].toLowerCase()];
+        const y = parseInt(monthMatch[2], 10);
+        return new Date(y, m, 1);
+    }
+    return null;
+}
+/** Extract referenced dates from content. */
+function extractContentDates(text) {
+    const results = [];
+    for (const pattern of [LAST_UPDATED_PATTERN, AS_OF_PATTERN]) {
+        const re = new RegExp(pattern.source, pattern.flags);
+        let m;
+        while ((m = re.exec(text)) !== null) {
+            const parsed = parseDateRef(m[1]);
+            if (parsed)
+                results.push({ label: m[0], date: parsed });
+        }
+    }
+    return results;
+}
+/**
+ * Detect stale knowledge nodes.
+ * Uses supersedes edges and date-based content heuristics.
+ */
+const detectStaleness = async (nodes, edges, _llm) => {
+    const detections = [];
+    const now = new Date();
+    const nodeMap = new Map(nodes.map((n) => [n.id, n]));
+    // Edge-based detection (existing)
+    const supersedesEdges = edges.filter((e) => e.type === 'supersedes');
+    for (const edge of supersedesEdges) {
+        const newer = nodeMap.get(edge.sourceId);
+        const older = nodeMap.get(edge.targetId);
+        if (!newer || !older)
+            continue;
+        const edgeCreated = edge.createdAt ?? new Date(0);
+        const olderLastModified = older.content.source?.lastModified ?? older.updatedAt;
+        if (olderLastModified >= edgeCreated)
+            continue;
+        const olderFile = older.content.source?.sourceId?.split('/').pop() ?? older.title;
+        const newerFile = newer.content.source?.sourceId?.split('/').pop() ?? newer.title;
+        detections.push({
+            type: 'staleness',
+            severity: 'warning',
+            nodeIds: [older.id, newer.id],
+            description: `"${older.title}" may be outdated — a newer version exists in "${newer.title}".`,
+            suggestedAction: `Review ${olderFile} and update it to match ${newerFile}, or mark it as superseded.`,
+            metadata: {
+                claimA: `Older: ${older.title} (${olderFile})`,
+                claimB: `Newer: ${newer.title} (${newerFile})`,
+                topic: 'version drift',
+            },
+        });
+    }
+    // Date-based heuristic: content referencing old dates
+    const superseededIds = new Set(supersedesEdges.map((e) => e.targetId));
+    for (const node of nodes) {
+        if (superseededIds.has(node.id))
+            continue; // already caught above
+        const raw = node.content.raw ?? '';
+        const text = `${node.title} ${node.content.summary} ${raw}`;
+        const refs = extractContentDates(text);
+        for (const ref of refs) {
+            const age = now.getTime() - ref.date.getTime();
+            if (age > SIX_MONTHS_MS) {
+                const monthsOld = Math.round(age / (30 * 24 * 60 * 60 * 1000));
+                const nodeFile = node.content.source?.sourceId?.split('/').pop() ?? node.title;
+                detections.push({
+                    type: 'staleness',
+                    severity: 'info',
+                    nodeIds: [node.id],
+                    description: `"${node.title}" references "${ref.label}" (${monthsOld} months ago) — content may be outdated.`,
+                    suggestedAction: `Review ${nodeFile} and verify the information is still current.`,
+                });
+                break; // one detection per node
+            }
+        }
+    }
+    // Deduplicate: group edge-based detections by older node
+    const byOlder = new Map();
+    const dateDetections = [];
+    for (const det of detections) {
+        if (det.type === 'staleness' && det.severity === 'warning' && det.nodeIds.length >= 2) {
+            const key = det.nodeIds[0];
+            const existing = byOlder.get(key);
+            if (existing) {
+                const merged = [...new Set([...existing.nodeIds, ...det.nodeIds])];
+                byOlder.set(key, {
+                    ...existing,
+                    nodeIds: merged,
+                    description: `${existing.description.split('.')[0]}. (${String(merged.length - 1)} newer versions found)`,
+                });
+            }
+            else {
+                byOlder.set(key, det);
+            }
+        }
+        else {
+            dateDetections.push(det);
+        }
+    }
+    return [...byOlder.values(), ...dateDetections];
+};
+detectStaleness.preFilter = {
+    similarityThreshold: 0.5,
+    topK: 15,
+};
+export { detectStaleness, extractContentDates, parseDateRef, SIX_MONTHS_MS };
+//# sourceMappingURL=staleness.js.map

package/dist/time-bomb-utils.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Date pattern parsing and deadline classification utilities for time bomb detection.
+ * Extracted from time-bombs.ts to keep files under 250 lines.
+ * @module time-bomb-utils
+ */
+import type { KnowledgeNode, Detection } from '@useody/platform-core';
+export declare const DATE_PATTERN: RegExp;
+export declare const QUARTER_PATTERN: RegExp;
+export declare const YYYY_MM_PATTERN: RegExp;
+export declare const BY_MONTH_YEAR: RegExp;
+export declare const BY_END_OF: RegExp;
+/** Parsed deadline result. */
+export interface ParsedDeadline {
+    label: string;
+    endDate: Date;
+}
+/** Extract deadline dates from text using regex patterns. */
+export declare function extractDeadlines(text: string, now: Date): ParsedDeadline[];
+/** Classify deadline relative to now. */
+export declare function classifyDeadline(deadline: ParsedDeadline, now: Date, nodeId: string, _nowLabel: string, docType?: string): Detection | null;
+/** Find a node that may have completed the deadline referenced by another node. */
+export declare function findCompletionNode(nodeId: string, nodeText: string, nodes: KnowledgeNode[]): string | undefined;
+//# sourceMappingURL=time-bomb-utils.d.ts.map

package/dist/time-bomb-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-bomb-utils.d.ts","sourceRoot":"","sources":["../src/time-bomb-utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAEtE,eAAO,MAAM,YAAY,QACwM,CAAC;AAElO,eAAO,MAAM,eAAe,QAA+B,CAAC;AAC5D,eAAO,MAAM,eAAe,QAA2B,CAAC;AACxD,eAAO,MAAM,aAAa,QACwG,CAAC;AACnI,eAAO,MAAM,SAAS,QACqB,CAAC;AAgD5C,8BAA8B;AAC9B,MAAM,WAAW,cAAc;IAC7B,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,IAAI,CAAC;CACf;AAED,6DAA6D;AAC7D,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,IAAI,GAAG,cAAc,EAAE,CA6C1E;AAED,yCAAyC;AACzC,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,cAAc,EACxB,GAAG,EAAE,IAAI,EACT,MAAM,EAAE,MAAM,EACd,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,MAAM,GACf,SAAS,GAAG,IAAI,CAkClB;AAiBD,mFAAmF;AACnF,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,aAAa,EAAE,GAAG,MAAM,GAAG,SAAS,CAgB/G"}

package/dist/time-bomb-utils.js

@@ -0,0 +1,161 @@
+export const DATE_PATTERN = /\b(Q[1-4]\s*20\d{2}|20\d{2}-\d{2}|by\s+(jan|feb|mar|apr|may|jun|jul|aug|sep|oct|nov|dec|january|february|march|april|may|june|july|august|september|october|november|december)\b|deadline|due\s+date|expires?|by\s+end\s+of)/i;
+export const QUARTER_PATTERN = /\bQ([1-4])\s*(20\d{2})\b/gi;
+export const YYYY_MM_PATTERN = /\b(20\d{2})-(\d{2})\b/g;
+export const BY_MONTH_YEAR = /\bby\s+(?:end\s+of\s+)?(january|february|march|april|may|june|july|august|september|october|november|december)\s+(20\d{2})\b/gi;
+export const BY_END_OF = /\bby\s+(?:end\s+of\s+)?(month|year)\b/gi;
+const MONTH_MAP = {
+    january: 0, february: 1, march: 2, april: 3,
+    may: 4, june: 5, july: 6, august: 7,
+    september: 8, october: 9, november: 10, december: 11,
+};
+const QUARTER_END_MONTH = [2, 5, 8, 11]; // Q1=Mar, Q2=Jun, Q3=Sep, Q4=Dec
+const COMPLETION_RE = /\b(completed|was\s+done|shipped|resolved|closed|merged|finished|delivered|launched|migrated|moved\s+from)\b/i;
+/** Check if a match position follows a document metadata label. */
+function isMetadataDate(text, index) {
+    const before = text.slice(Math.max(0, index - 50), index).replace(/\*+/g, '');
+    return /(?:last\s+updated|last\s+modified|updated|date|version|consolidated|created|published|generated)\s*:?\s*$/i.test(before.trimEnd());
+}
+/** Deadline-framing words near a YYYY-MM date. */
+const DEADLINE_CONTEXT_RE = /\b(deadline|due|by|expires?|target|complete|deliver|launch|ship|release|finish|submit|migrate|renewal|until|before|review)\b/i;
+/** Check if the sentence containing a YYYY-MM match has deadline-framing language. */
+function hasDeadlineContext(text, index) {
+    let start = index;
+    while (start > 0 && !/[.!?\n]/.test(text[start - 1]))
+        start--;
+    let end = index;
+    while (end < text.length && !/[.!?\n]/.test(text[end]))
+        end++;
+    const sent = text.slice(start, end);
+    return DEADLINE_CONTEXT_RE.test(sent);
+}
+/** Check if the sentence containing index already signals a completed past event. */
+function sentenceIsCompleted(text, index) {
+    let start = index;
+    while (start > 0 && !/[.!?\n]/.test(text[start - 1]))
+        start--;
+    let end = index;
+    while (end < text.length && !/[.!?\n]/.test(text[end]))
+        end++;
+    const sent = text.slice(start, end);
+    return COMPLETION_RE.test(sent);
+}
+/** Check if the match is inside a markdown table cell. */
+function isInTableCell(text, index) {
+    let lineStart = index;
+    while (lineStart > 0 && text[lineStart - 1] !== '\n')
+        lineStart--;
+    return text.slice(lineStart, index).trimStart().startsWith('|');
+}
+/** Extract deadline dates from text using regex patterns. */
+export function extractDeadlines(text, now) {
+    const results = [];
+    let match;
+    const qp = new RegExp(QUARTER_PATTERN.source, QUARTER_PATTERN.flags);
+    while ((match = qp.exec(text)) !== null) {
+        if (isInTableCell(text, match.index))
+            continue;
+        if (sentenceIsCompleted(text, match.index))
+            continue;
+        const q = parseInt(match[1], 10);
+        const year = parseInt(match[2], 10);
+        const endMonth = QUARTER_END_MONTH[q - 1];
+        const endDate = new Date(year, endMonth + 1, 0, 23, 59, 59);
+        results.push({ label: match[0], endDate });
+    }
+    const ymp = new RegExp(YYYY_MM_PATTERN.source, YYYY_MM_PATTERN.flags);
+    while ((match = ymp.exec(text)) !== null) {
+        if (isInTableCell(text, match.index))
+            continue;
+        if (isMetadataDate(text, match.index))
+            continue;
+        if (sentenceIsCompleted(text, match.index))
+            continue;
+        if (!hasDeadlineContext(text, match.index))
+            continue;
+        const year = parseInt(match[1], 10);
+        const month = parseInt(match[2], 10) - 1;
+        const endDate = new Date(year, month + 1, 0, 23, 59, 59);
+        results.push({ label: match[0], endDate });
+    }
+    const bmy = new RegExp(BY_MONTH_YEAR.source, BY_MONTH_YEAR.flags);
+    while ((match = bmy.exec(text)) !== null) {
+        const month = MONTH_MAP[match[1].toLowerCase()];
+        const year = parseInt(match[2], 10);
+        const endDate = new Date(year, month + 1, 0, 23, 59, 59);
+        results.push({ label: match[0], endDate });
+    }
+    const beo = new RegExp(BY_END_OF.source, BY_END_OF.flags);
+    while ((match = beo.exec(text)) !== null) {
+        const unit = match[1].toLowerCase();
+        const endDate = unit === 'year'
+            ? new Date(now.getFullYear(), 11, 31, 23, 59, 59)
+            : new Date(now.getFullYear(), now.getMonth() + 1, 0, 23, 59, 59);
+        results.push({ label: match[0], endDate });
+    }
+    return results;
+}
+/** Classify deadline relative to now. */
+export function classifyDeadline(deadline, now, nodeId, _nowLabel, docType) {
+    const diff = deadline.endDate.getTime() - now.getTime();
+    const thirtyDays = 30 * 24 * 60 * 60 * 1000;
+    const isMeetingNote = docType === 'meeting_notes' || docType === 'changelog';
+    if (diff < 0) {
+        const msPerMonth = 30 * 24 * 60 * 60 * 1000;
+        const monthsAgo = Math.round(-diff / msPerMonth);
+        const agoStr = monthsAgo <= 0 ? 'recently' : `${monthsAgo} month${monthsAgo === 1 ? '' : 's'} ago`;
+        const severity = isMeetingNote ? 'info' : 'warning';
+        const noteCtx = isMeetingNote ? ' (mentioned in meeting notes — verify if completed)' : '';
+        return {
+            type: 'time_bomb', severity, nodeIds: [nodeId],
+            description: `Deadline "${deadline.label}" has passed (${agoStr}).${noteCtx}`,
+            suggestedAction: isMeetingNote
+                ? `This deadline was mentioned in meeting notes. Check if it was completed in your task tracker.`
+                : `Deadline "${deadline.label}" has passed. Update or remove.`,
+            metadata: { deadline: deadline.label, expired: true, monthsAgo, docType },
+        };
+    }
+    if (diff <= thirtyDays) {
+        return {
+            type: 'time_bomb', severity: 'warning', nodeIds: [nodeId],
+            description: `Deadline approaching: "${deadline.label}".`,
+            suggestedAction: `Deadline "${deadline.label}" approaching. Verify status.`,
+            metadata: { deadline: deadline.label, expired: false, docType },
+        };
+    }
+    return {
+        type: 'time_bomb', severity: 'info', nodeIds: [nodeId],
+        description: `Future deadline: "${deadline.label}".`,
+        suggestedAction: `Deadline "${deadline.label}" is upcoming. Track it.`,
+        metadata: { deadline: deadline.label, expired: false, docType },
+    };
+}
+/** Extract topic words for cross-doc completion matching. */
+function topicWords(text) {
+    return new Set(text.toLowerCase().replace(/[^\w\s]/g, ' ').split(/\s+/).filter((w) => w.length >= 5));
+}
+/** Common words not useful for topic matching. */
+const COMMON_WORDS = new Set([
+    'services', 'project', 'company', 'classic',
+    'document', 'created', 'space', 'pages', 'https',
+    'about', 'which', 'their', 'there', 'these', 'those',
+    'would', 'could', 'should', 'other', 'after', 'before',
+]);
+/** Find a node that may have completed the deadline referenced by another node. */
+export function findCompletionNode(nodeId, nodeText, nodes) {
+    const topics = new Set([...topicWords(nodeText)].filter((w) => !COMMON_WORDS.has(w)));
+    if (topics.size < 2)
+        return undefined;
+    for (const n of nodes) {
+        if (n.id === nodeId)
+            continue;
+        const t = `${n.title} ${(n.content.facts ?? []).join(' ')} ${n.content.summary}`;
+        if (!COMPLETION_RE.test(t))
+            continue;
+        const otherTopics = new Set([...topicWords(t)].filter((w) => !COMMON_WORDS.has(w)));
+        const shared = [...otherTopics].filter((w) => topics.has(w));
+        if (shared.length >= 3)
+            return n.title;
+    }
+    return undefined;
+}
+//# sourceMappingURL=time-bomb-utils.js.map

package/dist/time-bombs.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Time bomb detector.
+ * Finds date-dependent commitments that have expired or will expire soon.
+ * @module time-bombs
+ */
+import type { DetectorFn } from '@useody/platform-core';
+import { extractDeadlines, classifyDeadline } from './time-bomb-utils.js';
+/**
+ * Detect date-dependent commitments that may have expired.
+ * Parses dates without LLM; uses LLM for richer analysis when available.
+ */
+declare const detectTimeBombs: DetectorFn;
+export { detectTimeBombs, extractDeadlines, classifyDeadline };
+//# sourceMappingURL=time-bombs.d.ts.map

package/dist/time-bombs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"time-bombs.d.ts","sourceRoot":"","sources":["../src/time-bombs.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,KAAK,EAIV,UAAU,EAEX,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAEL,gBAAgB,EAChB,gBAAgB,EAEjB,MAAM,sBAAsB,CAAC;AAE9B;;;GAGG;AACH,QAAA,MAAM,eAAe,EAAE,UAgHtB,CAAC;AAQF,OAAO,EAAE,eAAe,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,CAAC"}