@straiffi/archon 1.0.0

package/dist/server/lib/projectMemoryScan.js

@@ -0,0 +1,681 @@
+import { execFileSync } from 'child_process';
+import { existsSync, lstatSync, readdirSync, readFileSync } from 'fs';
+import { join } from 'path';
+import config from './config.js';
+import { runLightweightPrompt } from './lightweightPrompt.js';
+import { createProjectContextScan, getActiveProjectContextScan, getLatestProjectContextScan, getLatestSuccessfulProjectContextScan, replaceProjectContextArtifacts, updateProjectContextScan, } from './projectMemory.js';
+import { getProjectById } from './projects.js';
+import { enqueue, isRunning } from './queue.js';
+const SCAN_JOB_PREFIX = 'project-context-scan';
+const TOP_LEVEL_TEXT_FILES = ['AGENTS.md', 'CLAUDE.md', 'package.json', 'pnpm-workspace.yaml', 'turbo.json', 'tsconfig.json', 'pyproject.toml', 'Cargo.toml', 'go.mod', 'composer.json'];
+const HIGH_VALUE_DIRECTORIES = ['src', 'app', 'client', 'server', 'packages', 'libs', 'components', 'api', 'docs', 'tests'];
+const MAX_TOP_LEVEL_ENTRIES = 40;
+const MAX_FILE_CHARS = 4_000;
+const MAX_DIRECTORY_CHILDREN = 8;
+const MAX_HIGH_VALUE_DIRECTORIES = 6;
+const MAX_DIRECTORY_DEPTH = 4;
+const MAX_DIRECTORY_SNAPSHOT_LINES = 80;
+const MAX_VISIBLE_TEST_FILES = 32;
+const MAX_REPRESENTATIVE_SOURCE_FILES = 12;
+const MAX_REPRESENTATIVE_SOURCE_FILES_PER_DIRECTORY = 2;
+const MAX_REPRESENTATIVE_TEST_FILES = 2;
+const MAX_REPRESENTATIVE_FILE_CHARS = 2_500;
+const MAX_REPRESENTATIVE_DIRECTORY_CHILDREN = 16;
+const MAX_REPRESENTATIVE_CANDIDATES = 160;
+const STALE_SCAN_WARNING_AGE_MS = 14 * 24 * 60 * 60 * 1000;
+const IGNORED_DIRECTORY_NAMES = new Set(['.git', '.next', '.turbo', 'build', 'coverage', 'dist', 'node_modules', 'tmp']);
+const TEST_CONFIG_FILE_NAMES = new Set(['jest.config.js', 'jest.config.ts', 'playwright.config.js', 'playwright.config.ts', 'vitest.config.js', 'vitest.config.ts']);
+const PRIORITY_DIRECTORY_NAMES = new Set([
+    '__tests__',
+    'api',
+    'app',
+    'client',
+    'components',
+    'hooks',
+    'lib',
+    'pages',
+    'routes',
+    'server',
+    'src',
+    'tests',
+    'workers',
+    'workspace',
+]);
+const PRIORITY_FILE_PATTERNS = [
+    /^(main|index|app|server|client)\.[^.]+$/i,
+    /^route(?:r|s)?\.[^.]+$/i,
+    /^vite\.config\.[^.]+$/i,
+    /^vitest\.config\.[^.]+$/i,
+    /^jest\.config\.[^.]+$/i,
+    /^playwright\.config\.[^.]+$/i,
+    /^package\.json$/i,
+    /^tsconfig(?:\.[^.]+)?\.json$/i,
+];
+const REPRESENTATIVE_SOURCE_FILE_PATTERN = /\.(ts|tsx|js|jsx|mjs|cjs|mts|cts|py|go|rs|java|kt|kts|php|rb|swift|vue|svelte)$/i;
+const getScanJobKey = (projectId) => `${SCAN_JOB_PREFIX}:${projectId}`;
+const truncateText = (value, limit) => {
+    if (value.length <= limit) {
+        return value;
+    }
+    return `${value.slice(0, limit).trimEnd()}\n...[truncated]`;
+};
+const safeListEntries = (directoryPath) => {
+    try {
+        return readdirSync(directoryPath).sort((left, right) => left.localeCompare(right));
+    }
+    catch {
+        return [];
+    }
+};
+const safeReadTextFile = (filePath, limit = MAX_FILE_CHARS) => {
+    try {
+        return truncateText(readFileSync(filePath, 'utf8'), limit);
+    }
+    catch {
+        return null;
+    }
+};
+const isDirectory = (targetPath) => {
+    try {
+        return lstatSync(targetPath).isDirectory();
+    }
+    catch {
+        return false;
+    }
+};
+const findReadme = (entries) => {
+    return entries.find(entry => {
+        const normalized = entry.toLowerCase();
+        return normalized === 'readme' || normalized.startsWith('readme.');
+    }) ?? null;
+};
+const isIgnoredDirectoryName = (entryName) => IGNORED_DIRECTORY_NAMES.has(entryName.toLowerCase());
+const scorePathPriority = (relativePath, isDirectoryEntry) => {
+    const normalized = relativePath.toLowerCase();
+    const segments = normalized.split('/');
+    const name = segments[segments.length - 1] ?? normalized;
+    let score = 0;
+    if (isDirectoryEntry) {
+        if (PRIORITY_DIRECTORY_NAMES.has(name)) {
+            score += 90;
+        }
+        if (name === '__tests__' || name === 'tests') {
+            score += 30;
+        }
+        if (segments.length <= 2) {
+            score += 12;
+        }
+        return score;
+    }
+    for (const pattern of PRIORITY_FILE_PATTERNS) {
+        if (pattern.test(name)) {
+            score += 120;
+            break;
+        }
+    }
+    if (REPRESENTATIVE_SOURCE_FILE_PATTERN.test(name)) {
+        score += 30;
+    }
+    if (isVisibleTestFile(relativePath)) {
+        score += 120;
+    }
+    if (normalized.startsWith('client/src/')) {
+        score += 35;
+    }
+    if (normalized.startsWith('server/')) {
+        score += 35;
+    }
+    if (normalized.includes('/workers/')) {
+        score += 20;
+    }
+    if (normalized.includes('/api/')) {
+        score += 18;
+    }
+    if (normalized.includes('/routes/')) {
+        score += 18;
+    }
+    if (normalized.includes('/lib/')) {
+        score += 16;
+    }
+    if (normalized.includes('/components/')) {
+        score += 12;
+    }
+    if (segments.length <= 3) {
+        score += 14;
+    }
+    return score;
+};
+const listPrioritizedEntries = (directoryPath, relativeDirectoryPath, limit) => {
+    return safeListEntries(directoryPath)
+        .filter(entry => !isIgnoredDirectoryName(entry))
+        .map(entry => {
+        const path = join(directoryPath, entry);
+        const relativePath = relativeDirectoryPath ? `${relativeDirectoryPath}/${entry}` : entry;
+        const directory = isDirectory(path);
+        return {
+            name: entry,
+            path,
+            relativePath,
+            isDirectory: directory,
+            score: scorePathPriority(relativePath, directory),
+        };
+    })
+        .sort((left, right) => right.score - left.score || left.name.localeCompare(right.name))
+        .slice(0, limit);
+};
+const isVisibleTestFile = (relativePath) => {
+    const normalized = relativePath.toLowerCase();
+    const segments = normalized.split('/');
+    const fileName = segments[segments.length - 1] ?? normalized;
+    return TEST_CONFIG_FILE_NAMES.has(fileName)
+        || normalized.includes('/__tests__/')
+        || normalized.startsWith('__tests__/')
+        || normalized.startsWith('tests/')
+        || /\.(test|spec)\.[^.]+$/.test(fileName);
+};
+const isRepresentativeSourceFile = (relativePath) => {
+    const normalized = relativePath.toLowerCase();
+    const fileName = normalized.split('/').at(-1) ?? normalized;
+    return !isVisibleTestFile(relativePath)
+        && (REPRESENTATIVE_SOURCE_FILE_PATTERN.test(fileName) || fileName === 'package.json');
+};
+const collectDirectoryFileCandidates = (projectPath, directoryName) => {
+    const directoryPath = join(projectPath, directoryName);
+    if (!isDirectory(directoryPath)) {
+        return [];
+    }
+    const matches = [];
+    const seen = new Set();
+    const visitDirectory = (currentPath, relativePath, depth) => {
+        if (depth >= MAX_DIRECTORY_DEPTH || matches.length >= MAX_REPRESENTATIVE_CANDIDATES) {
+            return;
+        }
+        const entries = listPrioritizedEntries(currentPath, relativePath, MAX_REPRESENTATIVE_DIRECTORY_CHILDREN);
+        for (const entry of entries) {
+            if (entry.isDirectory) {
+                visitDirectory(entry.path, entry.relativePath, depth + 1);
+                continue;
+            }
+            if (matches.length >= MAX_REPRESENTATIVE_CANDIDATES || seen.has(entry.relativePath)) {
+                continue;
+            }
+            seen.add(entry.relativePath);
+            matches.push(entry.relativePath);
+        }
+    };
+    visitDirectory(directoryPath, directoryName, 0);
+    return matches;
+};
+const selectRepresentativeFiles = (projectPath, directoryNames, predicate, maxTotal, maxPerDirectory) => {
+    const selected = [];
+    const seen = new Set();
+    const overflow = [];
+    for (const directoryName of directoryNames) {
+        const directoryMatches = collectDirectoryFileCandidates(projectPath, directoryName)
+            .filter(predicate)
+            .map(relativePath => ({
+            name: relativePath.split('/').at(-1) ?? relativePath,
+            path: join(projectPath, relativePath),
+            relativePath,
+            isDirectory: false,
+            score: scorePathPriority(relativePath, false),
+        }))
+            .sort((left, right) => right.score - left.score || left.relativePath.localeCompare(right.relativePath));
+        for (const entry of directoryMatches.slice(0, maxPerDirectory)) {
+            if (selected.length >= maxTotal || seen.has(entry.relativePath)) {
+                continue;
+            }
+            seen.add(entry.relativePath);
+            selected.push(entry.relativePath);
+        }
+        overflow.push(...directoryMatches.slice(maxPerDirectory));
+    }
+    overflow.sort((left, right) => right.score - left.score || left.relativePath.localeCompare(right.relativePath));
+    for (const entry of overflow) {
+        if (selected.length >= maxTotal || seen.has(entry.relativePath)) {
+            continue;
+        }
+        seen.add(entry.relativePath);
+        selected.push(entry.relativePath);
+    }
+    return selected;
+};
+const appendDirectorySnapshot = (lines, directoryPath, relativeDirectoryPath, depth, budget) => {
+    if (depth >= MAX_DIRECTORY_DEPTH || budget.remaining <= 0) {
+        return;
+    }
+    const childEntries = listPrioritizedEntries(directoryPath, relativeDirectoryPath, MAX_DIRECTORY_CHILDREN);
+    for (const entry of childEntries) {
+        if (budget.remaining <= 0) {
+            return;
+        }
+        lines.push(`${'  '.repeat(depth)}- ${entry.name}${entry.isDirectory ? '/' : ''}`);
+        budget.remaining -= 1;
+        if (entry.isDirectory) {
+            appendDirectorySnapshot(lines, entry.path, entry.relativePath, depth + 1, budget);
+        }
+    }
+};
+const collectVisibleTestFiles = (projectPath, directoryNames) => {
+    const matches = [];
+    const seen = new Set();
+    const addMatch = (relativePath) => {
+        if (!isVisibleTestFile(relativePath) || seen.has(relativePath) || matches.length >= MAX_VISIBLE_TEST_FILES) {
+            return;
+        }
+        seen.add(relativePath);
+        matches.push(relativePath);
+    };
+    for (const entry of safeListEntries(projectPath)) {
+        if (!isDirectory(join(projectPath, entry))) {
+            addMatch(entry);
+        }
+    }
+    const visitDirectory = (directoryPath, relativePath, depth) => {
+        if (depth >= MAX_DIRECTORY_DEPTH || matches.length >= MAX_VISIBLE_TEST_FILES) {
+            return;
+        }
+        const childEntries = listPrioritizedEntries(directoryPath, relativePath, MAX_DIRECTORY_CHILDREN);
+        for (const entry of childEntries) {
+            if (matches.length >= MAX_VISIBLE_TEST_FILES) {
+                return;
+            }
+            if (entry.isDirectory) {
+                visitDirectory(entry.path, entry.relativePath, depth + 1);
+                continue;
+            }
+            addMatch(entry.relativePath);
+        }
+    };
+    for (const directoryName of directoryNames) {
+        if (matches.length >= MAX_VISIBLE_TEST_FILES) {
+            break;
+        }
+        const directoryPath = join(projectPath, directoryName);
+        if (!isDirectory(directoryPath)) {
+            continue;
+        }
+        visitDirectory(directoryPath, directoryName, 0);
+    }
+    return matches;
+};
+const buildRepoSnapshot = (project) => {
+    const topLevelEntries = safeListEntries(project.repo_path);
+    const selectedTopLevelEntries = topLevelEntries.slice(0, MAX_TOP_LEVEL_ENTRIES);
+    const readmeName = findReadme(topLevelEntries);
+    const selectedFiles = [
+        ...(readmeName ? [readmeName] : []),
+        ...TOP_LEVEL_TEXT_FILES.filter(fileName => topLevelEntries.includes(fileName)),
+    ].filter((entry, index, values) => values.indexOf(entry) === index);
+    const highValueDirectories = HIGH_VALUE_DIRECTORIES
+        .filter(directoryName => isDirectory(join(project.repo_path, directoryName)))
+        .slice(0, MAX_HIGH_VALUE_DIRECTORIES);
+    const visibleTestFiles = collectVisibleTestFiles(project.repo_path, [
+        ...highValueDirectories,
+        '__tests__',
+        'tests',
+    ]);
+    const representativeSourceFiles = selectRepresentativeFiles(project.repo_path, highValueDirectories, isRepresentativeSourceFile, MAX_REPRESENTATIVE_SOURCE_FILES, MAX_REPRESENTATIVE_SOURCE_FILES_PER_DIRECTORY);
+    const representativeTestFiles = selectRepresentativeFiles(project.repo_path, [...highValueDirectories, '__tests__', 'tests'], isVisibleTestFile, MAX_REPRESENTATIVE_TEST_FILES, 1);
+    const sections = [];
+    sections.push('Top-level entries:');
+    sections.push(...selectedTopLevelEntries.map(entry => `- ${entry}`));
+    if (selectedFiles.length > 0) {
+        sections.push('');
+        sections.push('Top-level file excerpts:');
+        for (const fileName of selectedFiles) {
+            const content = safeReadTextFile(join(project.repo_path, fileName));
+            if (!content) {
+                continue;
+            }
+            sections.push(`File: ${fileName}`);
+            sections.push(content);
+            sections.push('');
+        }
+    }
+    if (highValueDirectories.length > 0) {
+        sections.push('');
+        sections.push('High-value directory snapshots:');
+        const budget = { remaining: MAX_DIRECTORY_SNAPSHOT_LINES };
+        for (const directoryName of highValueDirectories) {
+            if (budget.remaining <= 0) {
+                break;
+            }
+            const directoryPath = join(project.repo_path, directoryName);
+            sections.push(`- ${directoryName}/`);
+            budget.remaining -= 1;
+            const snapshotLines = [];
+            appendDirectorySnapshot(snapshotLines, directoryPath, directoryName, 1, budget);
+            sections.push(...(snapshotLines.length > 0 ? snapshotLines : ['  - [empty]']));
+        }
+    }
+    if (representativeSourceFiles.length > 0) {
+        sections.push('');
+        sections.push('Representative source excerpts:');
+        for (const relativePath of representativeSourceFiles) {
+            const content = safeReadTextFile(join(project.repo_path, relativePath), MAX_REPRESENTATIVE_FILE_CHARS);
+            if (!content) {
+                continue;
+            }
+            sections.push(`File: ${relativePath}`);
+            sections.push(content);
+            sections.push('');
+        }
+    }
+    if (representativeTestFiles.length > 0) {
+        sections.push('');
+        sections.push('Representative test excerpts:');
+        for (const relativePath of representativeTestFiles) {
+            const content = safeReadTextFile(join(project.repo_path, relativePath), MAX_REPRESENTATIVE_FILE_CHARS);
+            if (!content) {
+                continue;
+            }
+            sections.push(`File: ${relativePath}`);
+            sections.push(content);
+            sections.push('');
+        }
+    }
+    if (visibleTestFiles.length > 0) {
+        sections.push('');
+        sections.push('Visible test files:');
+        sections.push(...visibleTestFiles.map(filePath => `- ${filePath}`));
+    }
+    return sections.join('\n').trim();
+};
+const buildScanPrompt = (project, snapshot) => {
+    return [
+        'You create compact project-memory scan summaries for Archon.',
+        'Return strict JSON only. No markdown fences. No explanation.',
+        'Use this exact shape:',
+        '{"architecture_summary":"string","key_areas":["string"],"important_conventions":["string"],"known_risks_or_unknowns":["string"]}',
+        'Rules:',
+        '- Keep architecture_summary to 1 short paragraph.',
+        '- Keep each list item short and repo-specific.',
+        '- Do not invent facts that are not supported by the snapshot.',
+        '- Prefer explicit uncertainty in known_risks_or_unknowns over guessing.',
+        '- Use known_risks_or_unknowns for concrete repo-specific gaps or risks, not boilerplate missing-visibility disclaimers.',
+        '- Avoid generic warnings like "internals are not visible in this snapshot" when representative source excerpts are present.',
+        '- important_conventions should describe repo-specific patterns, not generic framework advice.',
+        `Project: ${project.name}`,
+        `Repo path: ${project.repo_path}`,
+        `<repo_snapshot>\n${snapshot}\n</repo_snapshot>`,
+    ].join('\n\n');
+};
+const isScanOldEnoughForStaleWarning = (updatedAt) => {
+    const updatedAtTime = Date.parse(updatedAt);
+    if (Number.isNaN(updatedAtTime)) {
+        return true;
+    }
+    return Date.now() - updatedAtTime >= STALE_SCAN_WARNING_AGE_MS;
+};
+const extractFirstJsonObject = (value) => {
+    const normalized = value.trim();
+    if (normalized.startsWith('{') && normalized.endsWith('}')) {
+        return JSON.parse(normalized);
+    }
+    for (let startIndex = 0; startIndex < normalized.length; startIndex += 1) {
+        if (normalized[startIndex] !== '{') {
+            continue;
+        }
+        let depth = 0;
+        let inString = false;
+        let escaping = false;
+        for (let index = startIndex; index < normalized.length; index += 1) {
+            const character = normalized[index];
+            if (inString) {
+                if (escaping) {
+                    escaping = false;
+                    continue;
+                }
+                if (character === '\\') {
+                    escaping = true;
+                    continue;
+                }
+                if (character === '"') {
+                    inString = false;
+                }
+                continue;
+            }
+            if (character === '"') {
+                inString = true;
+                continue;
+            }
+            if (character === '{') {
+                depth += 1;
+                continue;
+            }
+            if (character === '}') {
+                depth -= 1;
+                if (depth === 0) {
+                    return JSON.parse(normalized.slice(startIndex, index + 1));
+                }
+            }
+        }
+    }
+    throw new Error('The scan model did not return valid JSON.');
+};
+const normalizeString = (value) => {
+    if (typeof value !== 'string') {
+        return '';
+    }
+    return value.trim();
+};
+const normalizeStringArray = (value) => {
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    const normalized = [];
+    for (const item of value) {
+        if (typeof item !== 'string') {
+            continue;
+        }
+        const trimmed = item.trim();
+        if (trimmed && !normalized.includes(trimmed)) {
+            normalized.push(trimmed);
+        }
+    }
+    return normalized;
+};
+const normalizeScanResult = (value) => {
+    const parsed = value && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : {};
+    return {
+        architecture_summary: normalizeString(parsed.architecture_summary),
+        key_areas: normalizeStringArray(parsed.key_areas),
+        important_conventions: normalizeStringArray(parsed.important_conventions),
+        known_risks_or_unknowns: normalizeStringArray(parsed.known_risks_or_unknowns),
+    };
+};
+const buildSection = (title, items) => {
+    if (items.length === 0) {
+        return '';
+    }
+    return `${title}:\n${items.map(item => `- ${item}`).join('\n')}`;
+};
+const buildSummaryMarkdown = (result) => {
+    const sections = [
+        result.architecture_summary ? `Architecture:\n${result.architecture_summary}` : '',
+        buildSection('Key areas', result.key_areas),
+        buildSection('Important conventions', result.important_conventions),
+        buildSection('Risks and unknowns', result.known_risks_or_unknowns),
+    ].filter(Boolean);
+    return sections.join('\n\n') || null;
+};
+const toArtifactMarkdown = (items) => {
+    return items.length > 0 ? items.map(item => `- ${item}`).join('\n') : null;
+};
+const buildArtifacts = (result) => {
+    const artifacts = [];
+    if (result.architecture_summary) {
+        artifacts.push({
+            kind: 'architecture',
+            title: 'Architecture',
+            content_json: JSON.stringify({ summary: result.architecture_summary }),
+            content_markdown: result.architecture_summary,
+        });
+    }
+    if (result.key_areas.length > 0) {
+        artifacts.push({
+            kind: 'key_areas',
+            title: 'Key areas',
+            content_json: JSON.stringify(result.key_areas),
+            content_markdown: toArtifactMarkdown(result.key_areas),
+        });
+    }
+    if (result.important_conventions.length > 0) {
+        artifacts.push({
+            kind: 'conventions',
+            title: 'Inferred conventions',
+            content_json: JSON.stringify(result.important_conventions),
+            content_markdown: toArtifactMarkdown(result.important_conventions),
+        });
+    }
+    if (result.known_risks_or_unknowns.length > 0) {
+        artifacts.push({
+            kind: 'risks',
+            title: 'Risks and unknowns',
+            content_json: JSON.stringify(result.known_risks_or_unknowns),
+            content_markdown: toArtifactMarkdown(result.known_risks_or_unknowns),
+        });
+    }
+    return artifacts;
+};
+const resolveScanExecution = (project) => {
+    if (project.helper_model) {
+        return {
+            tool: 'opencode',
+            model: project.helper_model,
+            variant: project.helper_variant,
+        };
+    }
+    return {
+        tool: config.tool ?? 'opencode',
+        model: null,
+        variant: null,
+    };
+};
+const runGitText = (args, cwd) => {
+    return execFileSync('git', args, {
+        cwd,
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'pipe'],
+    }).trim();
+};
+export const getProjectRepoAnchor = (project) => {
+    if (!existsSync(project.repo_path)) {
+        return { branch: null, head: null };
+    }
+    try {
+        const branchOutput = runGitText(['branch', '--show-current'], project.repo_path);
+        const headOutput = runGitText(['rev-parse', 'HEAD'], project.repo_path);
+        return {
+            branch: branchOutput && branchOutput !== 'HEAD' ? branchOutput : null,
+            head: headOutput || null,
+        };
+    }
+    catch {
+        return { branch: null, head: null };
+    }
+};
+const executeProjectContextScan = async (projectId, scanId) => {
+    const project = getProjectById(projectId);
+    if (!project) {
+        throw new Error('Project not found');
+    }
+    if (!project.memory_enabled) {
+        throw new Error('Project memory is disabled for this project');
+    }
+    const anchor = getProjectRepoAnchor(project);
+    updateProjectContextScan(project.id, scanId, {
+        status: 'running',
+        repo_head: anchor.head,
+        repo_branch: anchor.branch,
+        error: null,
+    });
+    const execution = resolveScanExecution(project);
+    const snapshot = buildRepoSnapshot(project);
+    const prompt = buildScanPrompt(project, snapshot);
+    const rawOutput = await runLightweightPrompt(execution, prompt, project.repo_path);
+    const result = normalizeScanResult(extractFirstJsonObject(rawOutput));
+    const summaryMarkdown = buildSummaryMarkdown(result);
+    const artifacts = buildArtifacts(result);
+    replaceProjectContextArtifacts(project.id, scanId, artifacts);
+    const completedAnchor = getProjectRepoAnchor(project);
+    updateProjectContextScan(project.id, scanId, {
+        status: 'done',
+        repo_head: completedAnchor.head,
+        repo_branch: completedAnchor.branch,
+        summary_markdown: summaryMarkdown,
+        error: null,
+    });
+};
+export const enqueueProjectContextScan = (projectId, scanId) => {
+    const jobKey = getScanJobKey(projectId);
+    if (isRunning(jobKey)) {
+        return;
+    }
+    enqueue(jobKey, async () => {
+        try {
+            await executeProjectContextScan(projectId, scanId);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            updateProjectContextScan(projectId, scanId, {
+                status: 'error',
+                error: message,
+            });
+        }
+    });
+};
+export const startProjectContextScan = (projectId) => {
+    const project = getProjectById(projectId);
+    if (!project) {
+        return { status: 404, error: 'Not found' };
+    }
+    if (!project.memory_enabled) {
+        return { status: 409, error: 'Project memory is disabled for this project' };
+    }
+    const activeScan = getActiveProjectContextScan(project.id);
+    if (activeScan) {
+        return { status: 409, scan: activeScan };
+    }
+    const execution = resolveScanExecution(project);
+    const anchor = getProjectRepoAnchor(project);
+    const scan = createProjectContextScan(project.id, {
+        repo_head: anchor.head,
+        repo_branch: anchor.branch,
+        scanner_tool: execution.tool,
+        scanner_model: execution.model,
+        scanner_variant: execution.variant,
+    });
+    if (!scan) {
+        return { status: 500, error: 'Unable to create the project context scan' };
+    }
+    enqueueProjectContextScan(project.id, scan.id);
+    return { status: 202, scan };
+};
+export const getProjectContextResponse = (projectId) => {
+    const project = getProjectById(projectId);
+    if (!project) {
+        return {
+            scan: null,
+            stale: false,
+            current_repo_head: null,
+            current_repo_branch: null,
+        };
+    }
+    const currentAnchor = getProjectRepoAnchor(project);
+    const latestScan = getLatestProjectContextScan(project.id);
+    const latestSuccessfulScan = getLatestSuccessfulProjectContextScan(project.id);
+    return {
+        scan: latestScan,
+        stale: Boolean(latestSuccessfulScan?.repo_head
+            && currentAnchor.head
+            && latestSuccessfulScan.repo_head !== currentAnchor.head
+            && isScanOldEnoughForStaleWarning(latestSuccessfulScan.updated_at)),
+        current_repo_head: currentAnchor.head,
+        current_repo_branch: currentAnchor.branch,
+    };
+};
+//# sourceMappingURL=projectMemoryScan.js.map