@straiffi/archon 1.0.0

package/dist/server/lib/projectMemoryTransfer.js

@@ -0,0 +1,958 @@
+import { randomUUID } from 'crypto';
+import db from '../db.js';
+const PROJECT_MEMORY_ARCHIVE_EXPORT_VERSION = 3;
+const PROJECT_MEMORY_ARCHIVE_SUPPORTED_VERSIONS = [1, 2, 3];
+const PROJECT_MEMORY_STAGES = ['plan', 'build', 'review', 'follow_up', 'plan_follow_up', 'chat'];
+const PROJECT_CONVENTION_PRIORITIES = ['critical', 'normal', 'low'];
+const PROJECT_CONVENTION_INJECTION_MODES = ['always', 'relevant'];
+const PROJECT_CONVENTION_STATUSES = ['active', 'archived'];
+const PROJECT_DECISION_STATUSES = ['accepted', 'archived', 'superseded'];
+const PROJECT_CONTEXT_SCAN_STATUSES = ['pending', 'running', 'done', 'error'];
+const PROJECT_CONTEXT_ARTIFACT_KINDS = ['architecture', 'key_areas', 'conventions', 'risks'];
+const TOOL_NAMES = ['claude', 'opencode'];
+const isRecord = (value) => {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+};
+const normalizeString = (value) => {
+    return String(value ?? '')
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+};
+const normalizeOptionalString = (value, fieldName) => {
+    if (value == null) {
+        return { value: null };
+    }
+    if (typeof value !== 'string') {
+        return { error: `${fieldName} must be a string or null` };
+    }
+    const trimmed = value.trim();
+    return { value: trimmed === '' ? null : trimmed };
+};
+const validateRequiredString = (value, fieldName) => {
+    if (typeof value !== 'string' || value.trim() === '') {
+        return { error: `${fieldName} must be a non-empty string` };
+    }
+    return { value: value.trim() };
+};
+const normalizeStringArray = (value, fieldName) => {
+    if (!Array.isArray(value)) {
+        return { error: `${fieldName} must be an array of strings` };
+    }
+    const normalized = [];
+    for (const entry of value) {
+        if (typeof entry !== 'string' || entry.trim() === '') {
+            return { error: `${fieldName} must be an array of strings` };
+        }
+        const trimmed = entry.trim();
+        if (!normalized.includes(trimmed)) {
+            normalized.push(trimmed);
+        }
+    }
+    return { value: normalized };
+};
+const validateStages = (value) => {
+    if (!Array.isArray(value)) {
+        return { error: 'memory.conventions[].stages must be an array of valid project memory stages' };
+    }
+    const normalized = [];
+    for (const stage of value) {
+        if (!PROJECT_MEMORY_STAGES.includes(stage)) {
+            return { error: 'memory.conventions[].stages must be an array of valid project memory stages' };
+        }
+        if (!normalized.includes(stage)) {
+            normalized.push(stage);
+        }
+    }
+    return { value: normalized };
+};
+const validateEnum = (value, values, fieldName) => {
+    if (!values.includes(value)) {
+        return { error: `${fieldName} must be one of ${values.join(', ')}` };
+    }
+    return { value: value };
+};
+const validateNullableEnum = (value, values, fieldName) => {
+    if (value == null) {
+        return { value: null };
+    }
+    return validateEnum(value, values, fieldName);
+};
+const parseJsonColumn = (value) => {
+    if (!value) {
+        return null;
+    }
+    try {
+        return JSON.parse(value);
+    }
+    catch {
+        return null;
+    }
+};
+const parseStringArrayColumn = (value) => {
+    const parsed = parseJsonColumn(value);
+    if (!Array.isArray(parsed)) {
+        return [];
+    }
+    return parsed
+        .filter((entry) => typeof entry === 'string')
+        .map(entry => entry.trim())
+        .filter(Boolean);
+};
+const serializeConvention = (row) => {
+    return {
+        title: row.title,
+        scope: row.scope,
+        instruction: row.instruction,
+        rationale: row.rationale,
+        stages: parseStringArrayColumn(row.stages_json),
+        priority: row.priority,
+        injection_mode: PROJECT_CONVENTION_INJECTION_MODES.includes(row.injection_mode)
+            ? row.injection_mode
+            : 'relevant',
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+const serializeDecision = (row) => {
+    return {
+        title: row.title,
+        scope: row.scope,
+        decision: row.decision,
+        rationale: row.rationale,
+        implications: parseStringArrayColumn(row.implications_json),
+        status: row.status,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+const serializeMemoryItemFromConvention = (row) => {
+    return {
+        kind: 'convention',
+        state: row.status,
+        source: 'manual',
+        title: row.title,
+        scope: row.scope,
+        content: row.instruction,
+        rationale: row.rationale,
+        implications: [],
+        stages: parseStringArrayColumn(row.stages_json),
+        priority: row.priority,
+        injection_mode: PROJECT_CONVENTION_INJECTION_MODES.includes(row.injection_mode)
+            ? row.injection_mode
+            : 'relevant',
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+const serializeMemoryItemFromDecision = (row) => {
+    return {
+        kind: 'decision',
+        state: row.status === 'accepted' ? 'active' : row.status,
+        source: 'manual',
+        title: row.title,
+        scope: row.scope,
+        content: row.decision,
+        rationale: row.rationale,
+        implications: parseStringArrayColumn(row.implications_json),
+        stages: [],
+        priority: null,
+        injection_mode: null,
+        created_at: row.created_at,
+        updated_at: row.updated_at,
+    };
+};
+const serializeArtifact = (row) => {
+    return {
+        kind: row.kind,
+        title: row.title,
+        content_json: parseJsonColumn(row.content_json),
+        content_markdown: row.content_markdown,
+        created_at: row.created_at,
+    };
+};
+const fingerprintConvention = (item) => {
+    return JSON.stringify([
+        normalizeString(item.title),
+        normalizeString(item.scope),
+        normalizeString(item.instruction),
+        normalizeString(item.rationale),
+        [...item.stages].sort(),
+        item.priority,
+        item.injection_mode,
+        item.status,
+    ]);
+};
+const fingerprintDecision = (item) => {
+    return JSON.stringify([
+        normalizeString(item.title),
+        normalizeString(item.scope),
+        normalizeString(item.decision),
+        normalizeString(item.rationale),
+        item.implications.map(entry => normalizeString(entry)),
+        item.status,
+    ]);
+};
+const fingerprintScan = (item) => {
+    return JSON.stringify([
+        item.status,
+        normalizeString(item.repo_head),
+        normalizeString(item.repo_branch),
+        item.scanner_tool,
+        normalizeString(item.scanner_model),
+        normalizeString(item.scanner_variant),
+        normalizeString(item.summary_markdown),
+        normalizeString(item.error),
+    ]);
+};
+const fingerprintArtifact = (item) => {
+    return JSON.stringify([
+        item.kind,
+        normalizeString(item.title),
+        item.content_json ?? null,
+        normalizeString(item.content_markdown),
+    ]);
+};
+const sanitizeJsonValue = (value) => {
+    if (value === undefined) {
+        return null;
+    }
+    return value;
+};
+const validateArchiveConvention = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'memory.conventions[] must be an object' };
+    }
+    const title = validateRequiredString(value.title, 'memory.conventions[].title');
+    if ('error' in title) {
+        return title;
+    }
+    const scope = normalizeOptionalString(value.scope, 'memory.conventions[].scope');
+    if ('error' in scope) {
+        return scope;
+    }
+    const instruction = validateRequiredString(value.instruction, 'memory.conventions[].instruction');
+    if ('error' in instruction) {
+        return instruction;
+    }
+    const rationale = normalizeOptionalString(value.rationale, 'memory.conventions[].rationale');
+    if ('error' in rationale) {
+        return rationale;
+    }
+    const stages = validateStages(value.stages);
+    if ('error' in stages) {
+        return stages;
+    }
+    const priority = validateEnum(value.priority, PROJECT_CONVENTION_PRIORITIES, 'memory.conventions[].priority');
+    if ('error' in priority) {
+        return priority;
+    }
+    const injectionMode = value.injection_mode == null
+        ? { value: 'relevant' }
+        : validateEnum(value.injection_mode, PROJECT_CONVENTION_INJECTION_MODES, 'memory.conventions[].injection_mode');
+    if ('error' in injectionMode) {
+        return injectionMode;
+    }
+    const status = validateEnum(value.status, PROJECT_CONVENTION_STATUSES, 'memory.conventions[].status');
+    if ('error' in status) {
+        return status;
+    }
+    const createdAt = validateRequiredString(value.created_at, 'memory.conventions[].created_at');
+    if ('error' in createdAt) {
+        return createdAt;
+    }
+    const updatedAt = validateRequiredString(value.updated_at, 'memory.conventions[].updated_at');
+    if ('error' in updatedAt) {
+        return updatedAt;
+    }
+    return {
+        value: {
+            title: title.value,
+            scope: scope.value,
+            instruction: instruction.value,
+            rationale: rationale.value,
+            stages: stages.value,
+            priority: priority.value,
+            injection_mode: injectionMode.value,
+            status: status.value,
+            created_at: createdAt.value,
+            updated_at: updatedAt.value,
+        },
+    };
+};
+const validateArchiveDecision = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'memory.decisions[] must be an object' };
+    }
+    const title = validateRequiredString(value.title, 'memory.decisions[].title');
+    if ('error' in title) {
+        return title;
+    }
+    const scope = normalizeOptionalString(value.scope, 'memory.decisions[].scope');
+    if ('error' in scope) {
+        return scope;
+    }
+    const decision = validateRequiredString(value.decision, 'memory.decisions[].decision');
+    if ('error' in decision) {
+        return decision;
+    }
+    const rationale = normalizeOptionalString(value.rationale, 'memory.decisions[].rationale');
+    if ('error' in rationale) {
+        return rationale;
+    }
+    const implications = normalizeStringArray(value.implications, 'memory.decisions[].implications');
+    if ('error' in implications) {
+        return implications;
+    }
+    const status = validateEnum(value.status, PROJECT_DECISION_STATUSES, 'memory.decisions[].status');
+    if ('error' in status) {
+        return status;
+    }
+    const createdAt = validateRequiredString(value.created_at, 'memory.decisions[].created_at');
+    if ('error' in createdAt) {
+        return createdAt;
+    }
+    const updatedAt = validateRequiredString(value.updated_at, 'memory.decisions[].updated_at');
+    if ('error' in updatedAt) {
+        return updatedAt;
+    }
+    return {
+        value: {
+            title: title.value,
+            scope: scope.value,
+            decision: decision.value,
+            rationale: rationale.value,
+            implications: implications.value,
+            status: status.value,
+            created_at: createdAt.value,
+            updated_at: updatedAt.value,
+        },
+    };
+};
+const validateArchiveItem = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'memory.items[] must be an object' };
+    }
+    const kind = validateEnum(value.kind, ['decision', 'convention'], 'memory.items[].kind');
+    if ('error' in kind) {
+        return kind;
+    }
+    const state = validateEnum(value.state, ['active', 'archived', 'superseded'], 'memory.items[].state');
+    if ('error' in state) {
+        return state;
+    }
+    const source = validateEnum(value.source, ['manual'], 'memory.items[].source');
+    if ('error' in source) {
+        return source;
+    }
+    if (kind.value === 'convention' && state.value === 'superseded') {
+        return { error: 'memory.items[] conventions cannot use the superseded state' };
+    }
+    const title = validateRequiredString(value.title, 'memory.items[].title');
+    if ('error' in title) {
+        return title;
+    }
+    const scope = normalizeOptionalString(value.scope, 'memory.items[].scope');
+    if ('error' in scope) {
+        return scope;
+    }
+    const content = validateRequiredString(value.content, 'memory.items[].content');
+    if ('error' in content) {
+        return content;
+    }
+    const rationale = normalizeOptionalString(value.rationale, 'memory.items[].rationale');
+    if ('error' in rationale) {
+        return rationale;
+    }
+    const implications = normalizeStringArray(value.implications ?? [], 'memory.items[].implications');
+    if ('error' in implications) {
+        return implications;
+    }
+    const stages = validateStages(value.stages ?? []);
+    if ('error' in stages) {
+        return { error: 'memory.items[].stages must be an array of valid project memory stages' };
+    }
+    const priority = value.priority == null
+        ? { value: null }
+        : validateEnum(value.priority, PROJECT_CONVENTION_PRIORITIES, 'memory.items[].priority');
+    if ('error' in priority) {
+        return priority;
+    }
+    const injectionMode = value.injection_mode == null
+        ? { value: null }
+        : validateEnum(value.injection_mode, PROJECT_CONVENTION_INJECTION_MODES, 'memory.items[].injection_mode');
+    if ('error' in injectionMode) {
+        return injectionMode;
+    }
+    if (kind.value === 'decision' && stages.value.length > 0) {
+        return { error: 'memory.items[] decisions cannot include stages' };
+    }
+    if (kind.value === 'decision' && priority.value !== null) {
+        return { error: 'memory.items[] decisions cannot include priority' };
+    }
+    if (kind.value === 'decision' && injectionMode.value !== null) {
+        return { error: 'memory.items[] decisions cannot include injection_mode' };
+    }
+    if (kind.value === 'convention' && implications.value.length > 0) {
+        return { error: 'memory.items[] conventions cannot include implications' };
+    }
+    if (kind.value === 'convention' && injectionMode.value === null) {
+        return { error: 'memory.items[] conventions must include injection_mode' };
+    }
+    const createdAt = validateRequiredString(value.created_at, 'memory.items[].created_at');
+    if ('error' in createdAt) {
+        return createdAt;
+    }
+    const updatedAt = validateRequiredString(value.updated_at, 'memory.items[].updated_at');
+    if ('error' in updatedAt) {
+        return updatedAt;
+    }
+    return {
+        value: {
+            kind: kind.value,
+            state: state.value,
+            source: source.value,
+            title: title.value,
+            scope: scope.value,
+            content: content.value,
+            rationale: rationale.value,
+            implications: implications.value,
+            stages: stages.value,
+            priority: priority.value,
+            injection_mode: injectionMode.value,
+            created_at: createdAt.value,
+            updated_at: updatedAt.value,
+        },
+    };
+};
+const validateArchiveArtifact = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'memory.scans[].artifacts[] must be an object' };
+    }
+    const kind = validateEnum(value.kind, PROJECT_CONTEXT_ARTIFACT_KINDS, 'memory.scans[].artifacts[].kind');
+    if ('error' in kind) {
+        return kind;
+    }
+    const title = validateRequiredString(value.title, 'memory.scans[].artifacts[].title');
+    if ('error' in title) {
+        return title;
+    }
+    const markdown = normalizeOptionalString(value.content_markdown, 'memory.scans[].artifacts[].content_markdown');
+    if ('error' in markdown) {
+        return markdown;
+    }
+    const createdAt = validateRequiredString(value.created_at, 'memory.scans[].artifacts[].created_at');
+    if ('error' in createdAt) {
+        return createdAt;
+    }
+    return {
+        value: {
+            kind: kind.value,
+            title: title.value,
+            content_json: sanitizeJsonValue(value.content_json),
+            content_markdown: markdown.value,
+            created_at: createdAt.value,
+        },
+    };
+};
+const validateArchiveScan = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'memory.scans[] must be an object' };
+    }
+    const status = validateEnum(value.status, PROJECT_CONTEXT_SCAN_STATUSES, 'memory.scans[].status');
+    if ('error' in status) {
+        return status;
+    }
+    const repoHead = normalizeOptionalString(value.repo_head, 'memory.scans[].repo_head');
+    if ('error' in repoHead) {
+        return repoHead;
+    }
+    const repoBranch = normalizeOptionalString(value.repo_branch, 'memory.scans[].repo_branch');
+    if ('error' in repoBranch) {
+        return repoBranch;
+    }
+    const scannerTool = validateNullableEnum(value.scanner_tool, TOOL_NAMES, 'memory.scans[].scanner_tool');
+    if ('error' in scannerTool) {
+        return scannerTool;
+    }
+    const scannerModel = normalizeOptionalString(value.scanner_model, 'memory.scans[].scanner_model');
+    if ('error' in scannerModel) {
+        return scannerModel;
+    }
+    const scannerVariant = normalizeOptionalString(value.scanner_variant, 'memory.scans[].scanner_variant');
+    if ('error' in scannerVariant) {
+        return scannerVariant;
+    }
+    const summaryMarkdown = normalizeOptionalString(value.summary_markdown, 'memory.scans[].summary_markdown');
+    if ('error' in summaryMarkdown) {
+        return summaryMarkdown;
+    }
+    const errorValue = normalizeOptionalString(value.error, 'memory.scans[].error');
+    if ('error' in errorValue) {
+        return errorValue;
+    }
+    const createdAt = validateRequiredString(value.created_at, 'memory.scans[].created_at');
+    if ('error' in createdAt) {
+        return createdAt;
+    }
+    const updatedAt = validateRequiredString(value.updated_at, 'memory.scans[].updated_at');
+    if ('error' in updatedAt) {
+        return updatedAt;
+    }
+    if (!Array.isArray(value.artifacts)) {
+        return { error: 'memory.scans[].artifacts must be an array' };
+    }
+    const artifacts = [];
+    for (const artifactValue of value.artifacts) {
+        const artifact = validateArchiveArtifact(artifactValue);
+        if ('error' in artifact) {
+            return artifact;
+        }
+        artifacts.push(artifact.value);
+    }
+    return {
+        value: {
+            status: status.value,
+            repo_head: repoHead.value,
+            repo_branch: repoBranch.value,
+            scanner_tool: scannerTool.value,
+            scanner_model: scannerModel.value,
+            scanner_variant: scannerVariant.value,
+            summary_markdown: summaryMarkdown.value,
+            error: errorValue.value,
+            created_at: createdAt.value,
+            updated_at: updatedAt.value,
+            artifacts,
+        },
+    };
+};
+export const validateProjectMemoryArchive = (value) => {
+    if (!isRecord(value)) {
+        return { error: 'Project memory archive must be an object' };
+    }
+    if (!PROJECT_MEMORY_ARCHIVE_SUPPORTED_VERSIONS.includes(value.schema_version)) {
+        return { error: `Unsupported project memory archive schema version: ${String(value.schema_version ?? 'missing')}` };
+    }
+    const exportedAt = validateRequiredString(value.exported_at, 'exported_at');
+    if ('error' in exportedAt) {
+        return exportedAt;
+    }
+    if (!isRecord(value.project)) {
+        return { error: 'project must be an object' };
+    }
+    const sourceProjectId = validateRequiredString(value.project.source_project_id, 'project.source_project_id');
+    if ('error' in sourceProjectId) {
+        return sourceProjectId;
+    }
+    const projectName = validateRequiredString(value.project.name, 'project.name');
+    if ('error' in projectName) {
+        return projectName;
+    }
+    if (typeof value.project.memory_enabled !== 'boolean') {
+        return { error: 'project.memory_enabled must be a boolean' };
+    }
+    if (!isRecord(value.memory)) {
+        return { error: 'memory must be an object' };
+    }
+    if (!Array.isArray(value.memory.scans)) {
+        return { error: 'memory.scans must be an array' };
+    }
+    const scans = [];
+    for (const scanValue of value.memory.scans) {
+        const scan = validateArchiveScan(scanValue);
+        if ('error' in scan) {
+            return scan;
+        }
+        scans.push(scan.value);
+    }
+    if (value.schema_version === 3) {
+        if (!Array.isArray(value.memory.items)) {
+            return { error: 'memory.items must be an array' };
+        }
+        const items = [];
+        for (const itemValue of value.memory.items) {
+            const item = validateArchiveItem(itemValue);
+            if ('error' in item) {
+                return item;
+            }
+            items.push(item.value);
+        }
+        return {
+            value: {
+                schema_version: 3,
+                exported_at: exportedAt.value,
+                project: {
+                    source_project_id: sourceProjectId.value,
+                    name: projectName.value,
+                    memory_enabled: value.project.memory_enabled,
+                },
+                memory: {
+                    items,
+                    scans,
+                },
+            },
+        };
+    }
+    if (!Array.isArray(value.memory.conventions)) {
+        return { error: 'memory.conventions must be an array' };
+    }
+    if (!Array.isArray(value.memory.decisions)) {
+        return { error: 'memory.decisions must be an array' };
+    }
+    const conventions = [];
+    for (const conventionValue of value.memory.conventions) {
+        const convention = validateArchiveConvention(conventionValue);
+        if ('error' in convention) {
+            return convention;
+        }
+        conventions.push(convention.value);
+    }
+    const decisions = [];
+    for (const decisionValue of value.memory.decisions) {
+        const decision = validateArchiveDecision(decisionValue);
+        if ('error' in decision) {
+            return decision;
+        }
+        decisions.push(decision.value);
+    }
+    return {
+        value: {
+            schema_version: value.schema_version,
+            exported_at: exportedAt.value,
+            project: {
+                source_project_id: sourceProjectId.value,
+                name: projectName.value,
+                memory_enabled: value.project.memory_enabled,
+            },
+            memory: {
+                conventions,
+                decisions,
+                scans,
+            },
+        },
+    };
+};
+export const exportProjectMemoryArchive = (project) => {
+    const conventionRows = db.prepare(`
+    SELECT *
+    FROM project_conventions
+    WHERE project_id = ?
+    ORDER BY created_at ASC, id ASC
+  `).all(project.id);
+    const decisionRows = db.prepare(`
+    SELECT *
+    FROM project_decisions
+    WHERE project_id = ?
+    ORDER BY created_at ASC, id ASC
+  `).all(project.id);
+    const scanRows = db.prepare(`
+    SELECT *
+    FROM project_context_scans
+    WHERE project_id = ?
+    ORDER BY created_at ASC, id ASC
+  `).all(project.id);
+    const artifactRows = db.prepare(`
+    SELECT *
+    FROM project_context_artifacts
+    WHERE project_id = ?
+    ORDER BY created_at ASC, id ASC
+  `).all(project.id);
+    const artifactsByScanId = new Map();
+    for (const artifactRow of artifactRows) {
+        const current = artifactsByScanId.get(artifactRow.scan_id) ?? [];
+        current.push(serializeArtifact(artifactRow));
+        artifactsByScanId.set(artifactRow.scan_id, current);
+    }
+    return {
+        schema_version: PROJECT_MEMORY_ARCHIVE_EXPORT_VERSION,
+        exported_at: new Date().toISOString(),
+        project: {
+            source_project_id: project.id,
+            name: project.name,
+            memory_enabled: Boolean(project.memory_enabled),
+        },
+        memory: {
+            items: [...conventionRows.map(serializeMemoryItemFromConvention), ...decisionRows.map(serializeMemoryItemFromDecision)]
+                .sort((left, right) => left.created_at.localeCompare(right.created_at) || left.updated_at.localeCompare(right.updated_at) || left.title.localeCompare(right.title)),
+            scans: scanRows.map(scanRow => ({
+                status: scanRow.status,
+                repo_head: scanRow.repo_head,
+                repo_branch: scanRow.repo_branch,
+                scanner_tool: scanRow.scanner_tool,
+                scanner_model: scanRow.scanner_model,
+                scanner_variant: scanRow.scanner_variant,
+                summary_markdown: scanRow.summary_markdown,
+                error: scanRow.error,
+                created_at: scanRow.created_at,
+                updated_at: scanRow.updated_at,
+                artifacts: artifactsByScanId.get(scanRow.id) ?? [],
+            })),
+        },
+    };
+};
+const buildExistingConventionTitleMap = (items) => {
+    const map = new Map();
+    for (const item of items) {
+        const title = normalizeString(item.title);
+        if (!title) {
+            continue;
+        }
+        const values = map.get(title) ?? new Set();
+        values.add(fingerprintConvention(item));
+        map.set(title, values);
+    }
+    return map;
+};
+const buildExistingDecisionTitleMap = (items) => {
+    const map = new Map();
+    for (const item of items) {
+        const title = normalizeString(item.title);
+        if (!title) {
+            continue;
+        }
+        const values = map.get(title) ?? new Set();
+        values.add(fingerprintDecision(item));
+        map.set(title, values);
+    }
+    return map;
+};
+const createConflict = (kind, title) => {
+    return {
+        kind,
+        title,
+        reason: 'title_conflict',
+    };
+};
+export const importProjectMemoryArchive = (projectId, archiveValue) => {
+    const archive = validateProjectMemoryArchive(archiveValue);
+    if ('error' in archive) {
+        return archive;
+    }
+    const result = {
+        summary: {
+            conventions_imported: 0,
+            conventions_skipped: 0,
+            decisions_imported: 0,
+            decisions_skipped: 0,
+            scans_imported: 0,
+            scans_skipped: 0,
+            artifacts_imported: 0,
+            artifacts_skipped: 0,
+        },
+        conflicts: [],
+    };
+    const transaction = db.transaction((validatedArchive) => {
+        const archiveConventions = validatedArchive.schema_version === 3
+            ? validatedArchive.memory.items
+                .filter((item) => item.kind === 'convention')
+                .map(item => ({
+                title: item.title,
+                scope: item.scope,
+                instruction: item.content,
+                rationale: item.rationale,
+                stages: item.stages,
+                priority: item.priority ?? 'normal',
+                injection_mode: item.injection_mode ?? 'relevant',
+                status: item.state === 'active' ? 'active' : 'archived',
+                created_at: item.created_at,
+                updated_at: item.updated_at,
+            }))
+            : validatedArchive.memory.conventions;
+        const archiveDecisions = validatedArchive.schema_version === 3
+            ? validatedArchive.memory.items
+                .filter((item) => item.kind === 'decision')
+                .map(item => ({
+                title: item.title,
+                scope: item.scope,
+                decision: item.content,
+                rationale: item.rationale,
+                implications: item.implications,
+                status: item.state === 'active' ? 'accepted' : item.state === 'archived' ? 'archived' : 'superseded',
+                created_at: item.created_at,
+                updated_at: item.updated_at,
+            }))
+            : validatedArchive.memory.decisions;
+        const existingConventionRows = db.prepare(`
+      SELECT *
+      FROM project_conventions
+      WHERE project_id = ?
+      ORDER BY created_at ASC, id ASC
+    `).all(projectId);
+        const existingDecisionRows = db.prepare(`
+      SELECT *
+      FROM project_decisions
+      WHERE project_id = ?
+      ORDER BY created_at ASC, id ASC
+    `).all(projectId);
+        const existingScanRows = db.prepare(`
+      SELECT *
+      FROM project_context_scans
+      WHERE project_id = ?
+      ORDER BY created_at ASC, id ASC
+    `).all(projectId);
+        const existingArtifactRows = db.prepare(`
+      SELECT *
+      FROM project_context_artifacts
+      WHERE project_id = ?
+      ORDER BY created_at ASC, id ASC
+    `).all(projectId);
+        const existingConventions = existingConventionRows.map(serializeConvention);
+        const existingDecisions = existingDecisionRows.map(serializeDecision);
+        const conventionFingerprints = new Set(existingConventions.map(fingerprintConvention));
+        const decisionFingerprints = new Set(existingDecisions.map(fingerprintDecision));
+        const conventionTitles = buildExistingConventionTitleMap(existingConventions);
+        const decisionTitles = buildExistingDecisionTitleMap(existingDecisions);
+        const insertConvention = db.prepare(`
+      INSERT INTO project_conventions (
+        id,
+        project_id,
+        title,
+        scope,
+        instruction,
+        rationale,
+        stages_json,
+        priority,
+        injection_mode,
+        status,
+        created_at,
+        updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertDecision = db.prepare(`
+      INSERT INTO project_decisions (
+        id,
+        project_id,
+        title,
+        scope,
+        decision,
+        rationale,
+        implications_json,
+        status,
+        created_at,
+        updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertScan = db.prepare(`
+      INSERT INTO project_context_scans (
+        id,
+        project_id,
+        status,
+        repo_head,
+        repo_branch,
+        scanner_tool,
+        scanner_model,
+        scanner_variant,
+        summary_markdown,
+        error,
+        created_at,
+        updated_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        const insertArtifact = db.prepare(`
+      INSERT INTO project_context_artifacts (
+        id,
+        scan_id,
+        project_id,
+        kind,
+        title,
+        content_json,
+        content_markdown,
+        created_at
+      ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        for (const convention of archiveConventions) {
+            const fingerprint = fingerprintConvention(convention);
+            const normalizedTitle = normalizeString(convention.title);
+            if (conventionFingerprints.has(fingerprint)) {
+                result.summary.conventions_skipped += 1;
+                continue;
+            }
+            const titleFingerprints = conventionTitles.get(normalizedTitle);
+            if (titleFingerprints && !titleFingerprints.has(fingerprint)) {
+                result.summary.conventions_skipped += 1;
+                result.conflicts.push(createConflict('convention', convention.title));
+                continue;
+            }
+            insertConvention.run(randomUUID(), projectId, convention.title, convention.scope, convention.instruction, convention.rationale, convention.stages.length > 0 ? JSON.stringify(convention.stages) : null, convention.priority, convention.injection_mode, convention.status, convention.created_at, convention.updated_at);
+            conventionFingerprints.add(fingerprint);
+            const nextTitleFingerprints = titleFingerprints ?? new Set();
+            nextTitleFingerprints.add(fingerprint);
+            conventionTitles.set(normalizedTitle, nextTitleFingerprints);
+            result.summary.conventions_imported += 1;
+        }
+        for (const decision of archiveDecisions) {
+            const fingerprint = fingerprintDecision(decision);
+            const normalizedTitle = normalizeString(decision.title);
+            if (decisionFingerprints.has(fingerprint)) {
+                result.summary.decisions_skipped += 1;
+                continue;
+            }
+            const titleFingerprints = decisionTitles.get(normalizedTitle);
+            if (titleFingerprints && !titleFingerprints.has(fingerprint)) {
+                result.summary.decisions_skipped += 1;
+                result.conflicts.push(createConflict('decision', decision.title));
+                continue;
+            }
+            insertDecision.run(randomUUID(), projectId, decision.title, decision.scope, decision.decision, decision.rationale, decision.implications.length > 0 ? JSON.stringify(decision.implications) : null, decision.status, decision.created_at, decision.updated_at);
+            decisionFingerprints.add(fingerprint);
+            const nextTitleFingerprints = titleFingerprints ?? new Set();
+            nextTitleFingerprints.add(fingerprint);
+            decisionTitles.set(normalizedTitle, nextTitleFingerprints);
+            result.summary.decisions_imported += 1;
+        }
+        const scanFingerprintToId = new Map();
+        for (const scanRow of existingScanRows) {
+            scanFingerprintToId.set(fingerprintScan({
+                status: scanRow.status,
+                repo_head: scanRow.repo_head,
+                repo_branch: scanRow.repo_branch,
+                scanner_tool: scanRow.scanner_tool,
+                scanner_model: scanRow.scanner_model,
+                scanner_variant: scanRow.scanner_variant,
+                summary_markdown: scanRow.summary_markdown,
+                error: scanRow.error,
+                created_at: scanRow.created_at,
+                updated_at: scanRow.updated_at,
+                artifacts: [],
+            }), scanRow.id);
+        }
+        const artifactFingerprintsByScanId = new Map();
+        for (const artifactRow of existingArtifactRows) {
+            const current = artifactFingerprintsByScanId.get(artifactRow.scan_id) ?? new Set();
+            current.add(fingerprintArtifact(serializeArtifact(artifactRow)));
+            artifactFingerprintsByScanId.set(artifactRow.scan_id, current);
+        }
+        for (const scan of validatedArchive.memory.scans) {
+            const scanFingerprint = fingerprintScan(scan);
+            let targetScanId = scanFingerprintToId.get(scanFingerprint);
+            if (targetScanId) {
+                result.summary.scans_skipped += 1;
+            }
+            else {
+                targetScanId = randomUUID();
+                insertScan.run(targetScanId, projectId, scan.status, scan.repo_head, scan.repo_branch, scan.scanner_tool, scan.scanner_model, scan.scanner_variant, scan.summary_markdown, scan.error, scan.created_at, scan.updated_at);
+                scanFingerprintToId.set(scanFingerprint, targetScanId);
+                artifactFingerprintsByScanId.set(targetScanId, new Set());
+                result.summary.scans_imported += 1;
+            }
+            const artifactFingerprints = artifactFingerprintsByScanId.get(targetScanId) ?? new Set();
+            artifactFingerprintsByScanId.set(targetScanId, artifactFingerprints);
+            for (const artifact of scan.artifacts) {
+                const artifactFingerprint = fingerprintArtifact(artifact);
+                if (artifactFingerprints.has(artifactFingerprint)) {
+                    result.summary.artifacts_skipped += 1;
+                    continue;
+                }
+                insertArtifact.run(randomUUID(), targetScanId, projectId, artifact.kind, artifact.title, artifact.content_json == null ? null : JSON.stringify(artifact.content_json), artifact.content_markdown, artifact.created_at);
+                artifactFingerprints.add(artifactFingerprint);
+                result.summary.artifacts_imported += 1;
+            }
+        }
+    });
+    transaction(archive.value);
+    return { value: result };
+};
+//# sourceMappingURL=projectMemoryTransfer.js.map