@jungjaehoon/mama-core 1.4.2 → 1.6.0

package/dist/cases/merge-split.js

@@ -0,0 +1,368 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeCases = mergeCases;
+exports.splitCase = splitCase;
+const node_crypto_1 = require("node:crypto");
+const canonicalize_js_1 = require("../canonicalize.js");
+const corrections_js_1 = require("./corrections.js");
+const sqlite_transaction_js_1 = require("./sqlite-transaction.js");
+const TERMINAL_CASE_STATUSES = new Set(['merged', 'archived', 'split']);
+const CHILD_UUID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+function normalizeNow(value) {
+    return value ?? new Date().toISOString();
+}
+function createdAtMs(now) {
+    const parsed = Date.parse(now);
+    return Number.isFinite(parsed) ? parsed : Date.now();
+}
+function nonEmpty(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function confirmed(input) {
+    return (input.confirmed === true && nonEmpty(input.confirmed_by) && nonEmpty(input.confirmation_summary));
+}
+function readCase(adapter, caseId) {
+    const row = adapter.prepare('SELECT * FROM case_truth WHERE case_id = ?').get(caseId);
+    return row ?? null;
+}
+function resolveCanonicalChain(adapter, caseId) {
+    const visited = new Set();
+    const chain = [];
+    let current = caseId;
+    for (;;) {
+        const depth = chain.length + 1;
+        const cycleChain = [...chain, current];
+        if (visited.has(current) || depth > 64) {
+            return {
+                kind: 'cycle',
+                message: `Case merge chain cycle detected at depth ${depth} starting from case_id=${caseId}. Chain=${cycleChain.join(' -> ')}.`,
+            };
+        }
+        visited.add(current);
+        chain.push(current);
+        const row = readCase(adapter, current);
+        if (!row) {
+            return { kind: 'precompile_gap', case_id: current };
+        }
+        if (!row.canonical_case_id) {
+            return { kind: 'resolved', terminal_case_id: current, chain };
+        }
+        current = row.canonical_case_id;
+    }
+}
+function insertMemoryEvent(input) {
+    const eventId = `me_${(0, node_crypto_1.randomUUID)()}`;
+    input.adapter
+        .prepare(`
+        INSERT INTO memory_events (
+          event_id, event_type, actor, source_turn_id, memory_id, topic,
+          scope_refs, evidence_refs, reason, created_at
+        )
+        VALUES (?, ?, 'user', NULL, NULL, ?, ?, ?, ?, ?)
+      `)
+        .run(eventId, input.event_type, input.topic, (0, canonicalize_js_1.canonicalizeJSON)(input.scope_refs), (0, canonicalize_js_1.canonicalizeJSON)(input.evidence_refs), (0, canonicalize_js_1.canonicalizeJSON)(input.reason), createdAtMs(input.now));
+    return eventId;
+}
+function hasCallerChildCaseIds(children) {
+    return children.some((child) => Object.prototype.hasOwnProperty.call(child, 'case_id'));
+}
+function trustedChildIdsAreValid(ids) {
+    return ids.every((id) => CHILD_UUID_PATTERN.test(id) && !id.startsWith('case_'));
+}
+function childIdsAreUnique(ids) {
+    return new Set(ids).size === ids.length;
+}
+function readParentMembership(adapter, parentCaseId, sourceType, sourceId) {
+    const row = adapter
+        .prepare(`
+        SELECT role, confidence, reason, status
+          FROM case_memberships
+         WHERE case_id = ?
+           AND source_type = ?
+           AND source_id = ?
+      `)
+        .get(parentCaseId, sourceType, sourceId);
+    return row ?? null;
+}
+function upsertChildMembership(input) {
+    input.adapter
+        .prepare(`
+        INSERT INTO case_memberships (
+          case_id, source_type, source_id, role, confidence, reason, status, added_by,
+          added_at, updated_at, user_locked
+        )
+        VALUES (?, ?, ?, ?, ?, ?, 'active', 'user-correction', ?, ?, 1)
+        ON CONFLICT(case_id, source_type, source_id) DO UPDATE SET
+          role = excluded.role,
+          confidence = excluded.confidence,
+          reason = excluded.reason,
+          status = 'active',
+          added_by = 'user-correction',
+          updated_at = excluded.updated_at,
+          user_locked = 1
+      `)
+        .run(input.child_case_id, input.source_type, input.source_id, input.parent_membership?.role ?? null, input.parent_membership?.confidence ?? null, input.parent_membership?.reason ?? 'User assigned source during case split.', input.now, input.now);
+}
+function removeParentMembership(input) {
+    input.adapter
+        .prepare(`
+        UPDATE case_memberships
+           SET status = 'removed',
+               user_locked = 1,
+               updated_at = ?
+         WHERE case_id = ?
+           AND source_type = ?
+           AND source_id = ?
+      `)
+        .run(input.now, input.parent_case_id, input.source_type, input.source_id);
+}
+function mergeCases(adapter, input) {
+    const tx = adapter;
+    if (!confirmed(input)) {
+        return {
+            kind: 'rejected',
+            code: 'case.confirmation_required',
+            message: 'confirmed=true, confirmed_by, and confirmation_summary are required.',
+        };
+    }
+    return (0, sqlite_transaction_js_1.runImmediateTransaction)(tx, () => {
+        const now = normalizeNow(input.now);
+        if (input.loser_case_id === input.survivor_case_id) {
+            return {
+                kind: 'rejected',
+                code: 'case.merge_self',
+                message: 'loser_case_id and survivor_case_id must be different.',
+            };
+        }
+        const loser = readCase(tx, input.loser_case_id);
+        if (!loser) {
+            return { kind: 'precompile_gap', code: 'case.precompile_gap', case_id: input.loser_case_id };
+        }
+        const survivor = readCase(tx, input.survivor_case_id);
+        if (!survivor) {
+            return {
+                kind: 'precompile_gap',
+                code: 'case.precompile_gap',
+                case_id: input.survivor_case_id,
+            };
+        }
+        const loserResolution = resolveCanonicalChain(tx, input.loser_case_id);
+        if (loserResolution.kind === 'cycle') {
+            return { kind: 'rejected', code: 'case.merge_chain_cycle', message: loserResolution.message };
+        }
+        if (loserResolution.kind === 'precompile_gap') {
+            return {
+                kind: 'precompile_gap',
+                code: 'case.precompile_gap',
+                case_id: loserResolution.case_id,
+            };
+        }
+        const survivorResolution = resolveCanonicalChain(tx, input.survivor_case_id);
+        if (survivorResolution.kind === 'cycle') {
+            return {
+                kind: 'rejected',
+                code: 'case.merge_chain_cycle',
+                message: survivorResolution.message,
+            };
+        }
+        if (survivorResolution.kind === 'precompile_gap') {
+            return {
+                kind: 'precompile_gap',
+                code: 'case.precompile_gap',
+                case_id: survivorResolution.case_id,
+            };
+        }
+        if (loserResolution.terminal_case_id === survivorResolution.terminal_case_id) {
+            return {
+                kind: 'rejected',
+                code: 'case.merge_self',
+                message: 'loser and survivor resolve to the same canonical case.',
+            };
+        }
+        const canonicalLoserCaseId = loserResolution.terminal_case_id;
+        const canonicalSurvivorCaseId = survivorResolution.terminal_case_id;
+        if (TERMINAL_CASE_STATUSES.has(loser.status) || TERMINAL_CASE_STATUSES.has(survivor.status)) {
+            return {
+                kind: 'rejected',
+                code: 'case.terminal_status',
+                message: 'Merged, archived, and split cases cannot be merge endpoints.',
+            };
+        }
+        (0, corrections_js_1.insertCaseCorrectionLock)(tx, {
+            case_id: canonicalLoserCaseId,
+            target_kind: 'case_field',
+            target_ref: { kind: 'case_field', field: 'canonical_case_id' },
+            field_name: null,
+            old_value_json: (0, canonicalize_js_1.canonicalizeJSON)({
+                status: loser.status,
+                canonical_case_id: loser.canonical_case_id,
+            }),
+            new_value_json: (0, canonicalize_js_1.canonicalizeJSON)({
+                status: 'merged',
+                canonical_case_id: canonicalSurvivorCaseId,
+            }),
+            reason: input.reason,
+            applied_by: input.confirmed_by,
+            applied_at: now,
+            is_lock_active: 0,
+        });
+        tx.prepare(`
+        UPDATE case_truth
+           SET status = 'merged',
+               canonical_case_id = ?,
+               updated_at = ?
+         WHERE case_id = ?
+      `).run(canonicalSurvivorCaseId, now, canonicalLoserCaseId);
+        const auditEventId = insertMemoryEvent({
+            adapter: tx,
+            event_type: 'case.merged',
+            topic: `case:${canonicalSurvivorCaseId}`,
+            scope_refs: [
+                { type: 'case', id: canonicalSurvivorCaseId },
+                { type: 'case', id: canonicalLoserCaseId },
+            ],
+            evidence_refs: [canonicalLoserCaseId, canonicalSurvivorCaseId],
+            reason: {
+                reason: input.reason,
+                confirmed_by: input.confirmed_by,
+                confirmation_summary: input.confirmation_summary,
+            },
+            now,
+        });
+        return {
+            kind: 'merged',
+            loser_case_id: input.loser_case_id,
+            survivor_case_id: input.survivor_case_id,
+            audit_event_id: auditEventId,
+        };
+    });
+}
+function splitCase(adapter, input) {
+    const tx = adapter;
+    if (!confirmed(input)) {
+        return {
+            kind: 'rejected',
+            code: 'case.confirmation_required',
+            message: 'confirmed=true, confirmed_by, and confirmation_summary are required.',
+        };
+    }
+    if (hasCallerChildCaseIds(input.children)) {
+        return {
+            kind: 'rejected',
+            code: 'case.child_id_not_trusted',
+            message: 'Child case IDs are runner-owned and must not be supplied in child payloads.',
+        };
+    }
+    if (input.children.length < 2) {
+        return {
+            kind: 'rejected',
+            code: 'case.split_requires_two_children',
+            message: 'A split requires at least two children.',
+        };
+    }
+    if (input.trusted_child_case_ids.length !== input.children.length) {
+        return {
+            kind: 'rejected',
+            code: 'case.child_id_count_mismatch',
+            message: 'trusted_child_case_ids length must match children length.',
+        };
+    }
+    if (!childIdsAreUnique(input.trusted_child_case_ids) ||
+        !trustedChildIdsAreValid(input.trusted_child_case_ids)) {
+        return {
+            kind: 'rejected',
+            code: 'case.child_id_not_trusted',
+            message: 'trusted_child_case_ids must be unique UUIDs minted by the standalone runner.',
+        };
+    }
+    return (0, sqlite_transaction_js_1.runImmediateTransaction)(tx, () => {
+        const now = normalizeNow(input.now);
+        const parent = readCase(tx, input.parent_case_id);
+        if (!parent) {
+            return { kind: 'precompile_gap', code: 'case.precompile_gap', case_id: input.parent_case_id };
+        }
+        if (TERMINAL_CASE_STATUSES.has(parent.status)) {
+            return {
+                kind: 'rejected',
+                code: 'case.terminal_status',
+                message: `Cannot split terminal case status ${parent.status}.`,
+            };
+        }
+        tx.prepare(`
+        UPDATE case_truth
+           SET status = 'split',
+               updated_at = ?
+         WHERE case_id = ?
+      `).run(now, input.parent_case_id);
+        for (const [index, child] of input.children.entries()) {
+            const childCaseId = input.trusted_child_case_ids[index];
+            tx.prepare(`
+          INSERT INTO case_truth (
+            case_id, current_wiki_path, title, status, split_from_case_id, wiki_path_history,
+            scope_refs, confidence, created_at, updated_at
+          )
+          VALUES (?, ?, ?, 'active', ?, '[]', ?, ?, ?, ?)
+        `).run(childCaseId, child.current_wiki_path ?? null, child.title, input.parent_case_id, parent.scope_refs ?? '[]', parent.confidence ?? null, now, now);
+            for (const membership of child.membership_sources) {
+                const sourceType = membership.source_type;
+                const parentMembership = readParentMembership(tx, input.parent_case_id, sourceType, membership.source_id);
+                upsertChildMembership({
+                    adapter: tx,
+                    child_case_id: childCaseId,
+                    source_type: sourceType,
+                    source_id: membership.source_id,
+                    parent_membership: parentMembership,
+                    now,
+                });
+                if (membership.remove_from_parent === true) {
+                    removeParentMembership({
+                        adapter: tx,
+                        parent_case_id: input.parent_case_id,
+                        source_type: sourceType,
+                        source_id: membership.source_id,
+                        now,
+                    });
+                }
+            }
+        }
+        (0, corrections_js_1.insertCaseCorrectionLock)(tx, {
+            case_id: input.parent_case_id,
+            target_kind: 'case_field',
+            target_ref: { kind: 'case_field', field: 'status' },
+            field_name: 'status',
+            old_value_json: (0, canonicalize_js_1.canonicalizeJSON)(parent.status),
+            new_value_json: (0, canonicalize_js_1.canonicalizeJSON)({
+                status: 'split',
+                child_case_ids: input.trusted_child_case_ids,
+            }),
+            reason: input.reason,
+            applied_by: input.confirmed_by,
+            applied_at: now,
+            is_lock_active: 0,
+        });
+        const auditEventId = insertMemoryEvent({
+            adapter: tx,
+            event_type: 'case.split',
+            topic: `case:${input.parent_case_id}`,
+            scope_refs: [
+                { type: 'case', id: input.parent_case_id },
+                ...input.trusted_child_case_ids.map((id) => ({ type: 'case', id })),
+            ],
+            evidence_refs: input.trusted_child_case_ids,
+            reason: {
+                reason: input.reason,
+                confirmed_by: input.confirmed_by,
+                confirmation_summary: input.confirmation_summary,
+                child_case_ids: input.trusted_child_case_ids,
+            },
+            now,
+        });
+        return {
+            kind: 'split',
+            parent_case_id: input.parent_case_id,
+            child_case_ids: input.trusted_child_case_ids,
+            audit_event_id: auditEventId,
+        };
+    });
+}
+//# sourceMappingURL=merge-split.js.map

package/dist/cases/role-inference.d.ts

@@ -0,0 +1,10 @@
+export type InferredCaseRole = 'requester' | 'implementer' | 'reviewer' | 'observer' | 'affected';
+interface InferTimelineEventRoleInput {
+    userText: string;
+    assistantText?: string;
+    eventType?: string;
+    actorHints?: string[];
+}
+export declare function inferTimelineEventRole(input: InferTimelineEventRoleInput): InferredCaseRole | null;
+export {};
+//# sourceMappingURL=role-inference.d.ts.map

package/dist/cases/role-inference.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.inferTimelineEventRole = inferTimelineEventRole;
+function hasPattern(text, patterns) {
+    return patterns.some((pattern) => pattern.test(text));
+}
+function joinText(parts) {
+    return parts.filter((part) => Boolean(part?.trim())).join('\n');
+}
+function mentionsActor(text, actorHints) {
+    return actorHints.some((hint) => {
+        const trimmed = hint.trim();
+        return trimmed.length > 0 && text.toLowerCase().includes(trimmed.toLowerCase());
+    });
+}
+const REQUESTER_PATTERNS = [
+    /\b(ask|asks|asked|request|requests|requested|please|can you|could you|would you|help me)\b/i,
+    /요청|해줘|해주세요|부탁|해주시|해 줄래|해 주실/i, // Korean: keyword patterns
+];
+const IMPLEMENTER_PATTERNS = [
+    /\b(i|we)\s+(will\s+handle|can\s+handle|implemented|fixed|built|handled|completed|shipped|worked\s+on|am\s+working\s+on)\b/i,
+    /\b(i'll|we'll)\s+handle\b/i,
+    /\b(implemented|fixed|built|handled|completed|shipped)\b/i,
+    /제가\s*(작업|수정|구현|처리|담당)|작업했습니다|수정했습니다|구현했습니다|담당합니다/i, // Korean: keyword patterns
+];
+const ACTOR_IMPLEMENTER_PATTERNS = [
+    /\b(will\s+handle|implemented|fixed|built|handled|completed|shipped|worked\s+on|owns\s+the\s+work)\b/i,
+    /작업|수정|구현|처리|담당/i, // Korean: keyword patterns
+];
+const REVIEWER_PATTERNS = [
+    /\b(reviewed|reviewing|review|approved|approve|approval)\b/i,
+    /검토|승인|리뷰/i, // Korean: keyword patterns
+];
+const AFFECTED_PATTERNS = [
+    /\b(blocked|waiting|held\s+up|impacted|affected|deferred|on\s+hold)\b/i,
+    /막힘|막혔|보류|대기|영향/i, // Korean: keyword patterns
+];
+const OBSERVER_PATTERNS = [
+    /\b(fyi|for your information|status-only|status only|heads up|observing)\b/i,
+    /참고|공유만|상태\s*공유|관찰/i, // Korean: keyword patterns
+];
+const AMBIGUOUS_OWNER_BLOCKER_PATTERNS = [/\b(owner|blocker)\b/i, /오너|소유자|블로커/i]; // Korean: keyword patterns
+function inferTimelineEventRole(input) {
+    const userText = input.userText.trim();
+    const assistantText = input.assistantText?.trim() ?? '';
+    const eventType = input.eventType?.trim() ?? '';
+    const actorHints = input.actorHints ?? [];
+    const combinedText = joinText([userText, assistantText, eventType, actorHints.join(' ')]);
+    if (!combinedText) {
+        return null;
+    }
+    const roles = new Set();
+    if (hasPattern(userText, REQUESTER_PATTERNS)) {
+        roles.add('requester');
+    }
+    const implementerText = joinText([assistantText, eventType]);
+    if (hasPattern(implementerText, IMPLEMENTER_PATTERNS)) {
+        roles.add('implementer');
+    }
+    if (mentionsActor(userText, actorHints) &&
+        hasPattern(userText, ACTOR_IMPLEMENTER_PATTERNS) &&
+        !hasPattern(userText, REQUESTER_PATTERNS)) {
+        roles.add('implementer');
+    }
+    if (hasPattern(joinText([assistantText, eventType]), REVIEWER_PATTERNS)) {
+        roles.add('reviewer');
+    }
+    if (mentionsActor(userText, actorHints) && hasPattern(userText, REVIEWER_PATTERNS)) {
+        roles.add('reviewer');
+    }
+    if (hasPattern(combinedText, AFFECTED_PATTERNS)) {
+        roles.add('affected');
+    }
+    if (hasPattern(combinedText, OBSERVER_PATTERNS)) {
+        roles.add('observer');
+    }
+    if (roles.size === 0 && hasPattern(combinedText, AMBIGUOUS_OWNER_BLOCKER_PATTERNS)) {
+        return null;
+    }
+    if (roles.size !== 1) {
+        return null;
+    }
+    return [...roles][0] ?? null;
+}
+//# sourceMappingURL=role-inference.js.map

package/dist/cases/search-rollup.d.ts

@@ -0,0 +1,27 @@
+import type { AdapterLike } from './wiki-page-index.js';
+import type { SearchHitDiagnostics } from '../search/search-quality.js';
+export type { AdapterLike };
+export interface SearchRollupLeafHit {
+    source_type: 'decision' | 'checkpoint' | 'wiki_page' | 'connector_event';
+    source_id: string;
+    fused_rank_score: number;
+    page_type?: 'case';
+    case_id?: string | null;
+    record: unknown;
+    retrieval_diagnostics?: SearchHitDiagnostics;
+}
+export interface SearchRollupResult {
+    source_type: 'decision' | 'checkpoint' | 'wiki_page' | 'case' | 'standalone_connector_hit';
+    source_id: string;
+    case_id: string | null;
+    score: number;
+    contributing_leaves?: string[];
+    contributing_leaf_diagnostics?: Record<string, SearchHitDiagnostics>;
+    retrieval_diagnostics?: SearchHitDiagnostics;
+    record: unknown;
+}
+export declare function rollUpSearchHits(input: {
+    fusedHits: SearchRollupLeafHit[];
+    adapter: AdapterLike;
+}): SearchRollupResult[];
+//# sourceMappingURL=search-rollup.d.ts.map