@anirudh242/contextbridge 0.1.0

package/dist/lib/git.js

@@ -0,0 +1,105 @@
+import { simpleGit } from 'simple-git';
+const EXCLUDED_PATHS = ['node_modules', 'dist', 'AGENTS.md'];
+function createGit(projectPath) {
+    return simpleGit({
+        baseDir: projectPath,
+        binary: 'git',
+        trimmed: false,
+    });
+}
+function buildPathspec() {
+    return ['.', ...EXCLUDED_PATHS.map((entry) => `:(exclude)${entry}`)];
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export async function isGitRepository(projectPath) {
+    try {
+        return await createGit(projectPath).checkIsRepo();
+    }
+    catch {
+        return false;
+    }
+}
+export async function getCurrentBranch(projectPath) {
+    try {
+        if (!(await isGitRepository(projectPath))) {
+            return 'no-git';
+        }
+        const branch = await createGit(projectPath).branchLocal();
+        return branch.current || 'detached';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+async function hasHeadCommit(git) {
+    try {
+        await git.revparse(['--verify', 'HEAD']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function hasPreviousCommit(git) {
+    try {
+        await git.revparse(['--verify', 'HEAD~1']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getGitContext(projectPath) {
+    const warnings = [];
+    try {
+        const repo = await isGitRepository(projectPath);
+        if (!repo) {
+            warnings.push('Git repository not detected. Skipping git diff and git log capture.');
+            return {
+                diff: '',
+                log: '',
+                status: '',
+                warnings,
+            };
+        }
+        const git = createGit(projectPath);
+        const headExists = await hasHeadCommit(git);
+        let diff = '';
+        let log = '';
+        let status = '';
+        if (headExists) {
+            log = await git.raw(['log', '--oneline', '-5']);
+            if (await hasPreviousCommit(git)) {
+                diff = await git.raw(['diff', 'HEAD~1', 'HEAD', '--', ...buildPathspec()]);
+            }
+            else {
+                diff = await git.diff(['HEAD', '--', ...buildPathspec()]);
+            }
+        }
+        else {
+            warnings.push('No commits found yet. Capturing unstaged diff only.');
+            diff = await git.diff(['--', ...buildPathspec()]);
+            status = (await git.raw(['status', '--short', '--', ...buildPathspec()])).trim();
+        }
+        if (!status) {
+            status = (await git.raw(['status', '--short', '--', ...buildPathspec()])).trim();
+        }
+        return {
+            diff,
+            log,
+            status,
+            warnings,
+        };
+    }
+    catch (error) {
+        warnings.push(`Git capture failed: ${getErrorMessage(error)}`);
+        return {
+            diff: '',
+            log: '',
+            status: '',
+            warnings,
+        };
+    }
+}

package/dist/lib/inject.js

@@ -0,0 +1,130 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { formatRelativeTime } from '../utils/display.js';
+import { loadRawCapture } from './store.js';
+function renderList(items, emptyLabel = 'Unknown') {
+    if (!items || items.length === 0) {
+        return `- ${emptyLabel}`;
+    }
+    return items.map((item) => `- ${item}`).join('\n');
+}
+function getFallbackTask(raw) {
+    if (raw.note.trim()) {
+        return raw.note.trim();
+    }
+    return 'Unknown';
+}
+function getPackageDescription(repoGrounding) {
+    const match = repoGrounding.match(/^description:\s*(.+)$/im);
+    return match?.[1]?.trim() || 'Unknown';
+}
+function compactGrounding(repoGrounding) {
+    const lines = repoGrounding
+        .split('\n')
+        .filter((line) => line.trim() !== 'Project grounding:')
+        .map((line) => line.trimEnd());
+    const packageStart = lines.findIndex((line) => line.trim() === 'package.json:');
+    const readmeStart = lines.findIndex((line) => line.trim() === 'README excerpt:');
+    const filesStart = lines.findIndex((line) => line.trim() === 'Relevant files:');
+    const packageBlock = packageStart === -1
+        ? []
+        : lines.slice(packageStart, readmeStart === -1 ? filesStart === -1 ? lines.length : filesStart : readmeStart)
+            .filter((line) => line.trim())
+            .slice(0, 6);
+    const readmeBlock = readmeStart === -1
+        ? []
+        : [
+            'README excerpt:',
+            ...lines
+                .slice(readmeStart + 1, filesStart === -1 ? lines.length : filesStart)
+                .filter((line) => line.trim())
+                .filter((line) => !line.startsWith('```'))
+                .slice(0, 8),
+        ];
+    const filesBlock = filesStart === -1
+        ? []
+        : [
+            'Relevant files:',
+            ...lines
+                .slice(filesStart + 1)
+                .filter((line) => /^-\s+/.test(line.trim()))
+                .filter((line) => !line.includes('package-lock.json'))
+                .slice(0, 10),
+        ];
+    const compacted = [
+        packageBlock.join('\n'),
+        readmeBlock.join('\n'),
+        filesBlock.join('\n'),
+    ].filter(Boolean).join('\n\n');
+    return compacted || repoGrounding.trim().slice(0, 1200);
+}
+function getTrustedSummary(entry) {
+    if (!entry.summary)
+        return null;
+    const missingCore = entry.summary.projectGoal === 'Unknown' &&
+        entry.summary.currentDirection === 'Unknown' &&
+        entry.summary.currentFocus === 'Unknown';
+    return missingCore ? null : entry.summary;
+}
+function sortNewestFirst(entries) {
+    return [...entries].sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+}
+function findTrustedSummaryEntry(entry, entries = []) {
+    const candidates = entries.length > 0 ? entries : [entry];
+    return sortNewestFirst(candidates).find((candidate) => getTrustedSummary(candidate) !== null) ?? null;
+}
+function buildFallbackDirection(raw, summary, trustedEntry, entryId) {
+    if (summary?.currentDirection && trustedEntry?.id === entryId) {
+        return summary.currentDirection;
+    }
+    if (summary?.currentDirection && trustedEntry) {
+        return summary.currentDirection;
+    }
+    const grounding = raw.repoGrounding.trim();
+    if (grounding) {
+        return 'No trusted summary is available yet. Use the project grounding below as the current source of truth.';
+    }
+    return 'Unknown';
+}
+export async function formatContextForInjection({ projectName, entry, entries = [] }) {
+    const trustedEntry = findTrustedSummaryEntry(entry, entries);
+    const summary = trustedEntry ? getTrustedSummary(trustedEntry) : null;
+    const raw = await loadRawCapture(entry.id);
+    if (!raw) {
+        throw new Error('Raw capture not found for the head entry.');
+    }
+    const grounding = compactGrounding(raw.repoGrounding);
+    const fallbackProjectGoal = getPackageDescription(raw.repoGrounding);
+    return [
+        `[ContextBridge] Project: ${projectName} | Branch: ${entry.branch ?? 'unknown'} | Captured: ${formatRelativeTime(entry.timestamp)}`,
+        trustedEntry && trustedEntry.id !== entry.id
+            ? `[ContextBridge] Summary source: latest trusted capture from ${formatRelativeTime(trustedEntry.timestamp)}`
+            : '',
+        '',
+        `What we're building: ${summary?.projectGoal ?? fallbackProjectGoal}`,
+        '',
+        `Current direction: ${buildFallbackDirection(raw, summary, trustedEntry, entry.id)}`,
+        '',
+        `Current implementation focus: ${summary?.currentFocus ?? getFallbackTask(raw)}`,
+        '',
+        'Recent decisions:',
+        renderList(summary?.decisions),
+        '',
+        'Blockers:',
+        renderList(summary?.blockers, 'None'),
+        '',
+        `Stack: ${summary?.stack ?? 'Unknown'}`,
+        '',
+        'Next steps:',
+        renderList(summary?.nextSteps),
+        '',
+        'Project grounding:',
+        grounding || '- Unknown',
+        '',
+    ].join('\n');
+}
+export async function writeAgentsFile(projectPath, content) {
+    const targetPath = path.join(projectPath, 'AGENTS.md');
+    await fs.writeFile(targetPath, `${content.trim()}\n`, 'utf8');
+    return targetPath;
+}

package/dist/lib/llm.js

@@ -0,0 +1,350 @@
+import { z } from 'zod';
+import { zodToJsonSchema } from 'zod-to-json-schema';
+const DEFAULT_MODEL = 'qwen2.5-coder:7b';
+const DEFAULT_URL = 'http://127.0.0.1:11434';
+const DEFAULT_TIMEOUT_MS = 120000;
+const summarySchema = z.object({
+    projectGoal: z.string().default('Unknown'),
+    currentDirection: z.string().default('Unknown'),
+    currentFocus: z.string().default('Unknown'),
+    decisions: z.array(z.string()).max(3).default([]),
+    blockers: z.array(z.string()).max(3).default(['None']),
+    stack: z.string().default('Unknown'),
+    nextSteps: z.array(z.string()).max(3).default([]),
+});
+const summaryJsonSchema = zodToJsonSchema(summarySchema, 'ContextSummary');
+function approximateTokens(text) {
+    return text.trim().split(/\s+/).filter(Boolean);
+}
+function truncateMiddleTokens(text, maxTokens = 6000, keepPerSide = 2000) {
+    const tokens = approximateTokens(text);
+    if (tokens.length <= maxTokens) {
+        return text;
+    }
+    const head = tokens.slice(0, keepPerSide).join(' ');
+    const tail = tokens.slice(-keepPerSide).join(' ');
+    return `${head}\n\n[... truncated middle content ...]\n\n${tail}`;
+}
+function buildPrompt(content) {
+    return [
+        'You are a developer context summariser.',
+        'Given the following content from a coding session, return a JSON object that matches the provided schema.',
+        'Field requirements:',
+        '- projectGoal: what this project is building overall',
+        '- currentDirection: the current product or implementation direction',
+        '- currentFocus: the specific work actively being done now',
+        '- decisions: up to 3 concrete technical or product decisions made',
+        '- blockers: up to 3 active blockers, or ["None"] if absent',
+        '- stack: language, frameworks, and the most relevant files touched',
+        '- nextSteps: up to 3 concrete implementation steps directly implied by the content',
+        'Be specific and technical. Use actual variable names, file names, and error text when present.',
+        'If information is missing, write "Unknown".',
+        'Do not invent generic workflow advice like creating a branch, committing changes, or writing tests unless the content explicitly says so.',
+        `JSON schema: ${JSON.stringify(summaryJsonSchema)}`,
+        '',
+        'Content:',
+        truncateMiddleTokens(content),
+    ].join('\n');
+}
+function buildFallbackPrompt(content) {
+    return [
+        'You are a developer context summariser.',
+        'Return a JSON object that matches the provided schema.',
+        'Use short, specific values. If unknown, write "Unknown".',
+        'Do not invent generic workflow advice.',
+        `JSON schema: ${JSON.stringify(summaryJsonSchema)}`,
+        '',
+        'Session content:',
+        truncateMiddleTokens(content, 2500, 800),
+    ].join('\n');
+}
+async function callAnthropic(prompt, config) {
+    const model = config.model || 'claude-haiku-4-5-20251001';
+    const baseUrl = config.baseUrl || 'https://api.anthropic.com';
+    const apiKey = config.apiKey;
+    if (!apiKey)
+        throw new Error('Anthropic API key is required');
+    const response = await fetch(`${baseUrl}/v1/messages`, {
+        method: 'POST',
+        headers: {
+            'x-api-key': apiKey,
+            'anthropic-version': '2023-06-01',
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            model,
+            max_tokens: 1024,
+            messages: [{ role: 'user', content: prompt }],
+        }),
+    });
+    if (!response.ok)
+        throw new Error(`Anthropic request failed with status ${response.status}`);
+    const payload = await response.json();
+    return payload.content[0].text;
+}
+async function callOpenAI(prompt, config) {
+    const model = config.model || 'gpt-4o-mini';
+    const baseUrl = config.baseUrl || 'https://api.openai.com';
+    const apiKey = config.apiKey;
+    if (!apiKey)
+        throw new Error('OpenAI API key is required');
+    const response = await fetch(`${baseUrl}/v1/chat/completions`, {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${apiKey}`,
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            model,
+            messages: [{ role: 'user', content: prompt }],
+            max_tokens: 1024,
+            temperature: 0,
+        }),
+    });
+    if (!response.ok)
+        throw new Error(`OpenAI request failed with status ${response.status}`);
+    const payload = await response.json();
+    return payload.choices[0].message.content;
+}
+async function callGemini(prompt, config) {
+    const model = config.model || 'gemini-2.0-flash';
+    const baseUrl = config.baseUrl || 'https://generativelanguage.googleapis.com';
+    const apiKey = config.apiKey;
+    if (!apiKey)
+        throw new Error('Gemini API key is required');
+    const response = await fetch(`${baseUrl}/v1beta/models/${model}:generateContent?key=${apiKey}`, {
+        method: 'POST',
+        headers: {
+            'content-type': 'application/json',
+        },
+        body: JSON.stringify({
+            contents: [{ parts: [{ text: prompt }] }],
+            generationConfig: { maxOutputTokens: 1024, temperature: 0 },
+        }),
+    });
+    if (!response.ok)
+        throw new Error(`Gemini request failed with status ${response.status}`);
+    const payload = await response.json();
+    return payload.candidates[0].content.parts[0].text;
+}
+async function callOllama(prompt, config) {
+    const model = config.model || DEFAULT_MODEL;
+    const baseUrl = config.baseUrl || DEFAULT_URL;
+    const timeoutMs = config.ollamaTimeoutMs === null
+        ? null
+        : (typeof config.ollamaTimeoutMs === 'number' && Number.isFinite(config.ollamaTimeoutMs)
+            ? config.ollamaTimeoutMs
+            : DEFAULT_TIMEOUT_MS);
+    const signal = timeoutMs === null ? undefined : AbortSignal.timeout(timeoutMs);
+    const response = await fetch(`${baseUrl}/api/generate`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model,
+            prompt,
+            stream: false,
+            format: summaryJsonSchema,
+            options: {
+                num_predict: 384,
+                temperature: 0,
+            },
+        }),
+        signal,
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama request failed with status ${response.status}`);
+    }
+    const payload = (await response.json());
+    return payload.response ?? '';
+}
+async function callLLM(prompt, config) {
+    switch (config.provider) {
+        case 'anthropic':
+            return callAnthropic(prompt, config);
+        case 'openai':
+            return callOpenAI(prompt, config);
+        case 'gemini':
+            return callGemini(prompt, config);
+        case 'ollama':
+        default:
+            return callOllama(prompt, config);
+    }
+}
+function normaliseList(value, fallback) {
+    if (!Array.isArray(value)) {
+        return fallback;
+    }
+    return value
+        .map((item) => `${item}`.trim())
+        .filter(Boolean)
+        .slice(0, 3);
+}
+function cleanLineValue(value) {
+    return value
+        .replace(/^[-*]\s*/, '')
+        .replace(/^"(.*)"$/, '$1')
+        .replace(/^`{1,3}|`{1,3}$/g, '')
+        .trim();
+}
+function extractSection(text, label, stopLabels) {
+    const escapedLabel = label.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    const escapedStops = stopLabels.map((item) => item.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'));
+    const pattern = new RegExp(`^\\s*(?:#+\\s*)?${escapedLabel}\\s*:\\s*([\\s\\S]*?)(?=^\\s*(?:#+\\s*)?(?:${escapedStops.join('|')})\\s*:|^\\s*\`\`\`|$)`, 'im');
+    const match = text.match(pattern);
+    return match?.[1]?.trim() ?? '';
+}
+function extractBullets(section, fallback) {
+    const bulletLines = section
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line) => /^[-*]\s+/.test(line))
+        .map((line) => cleanLineValue(line))
+        .filter((line) => line.length > 0 && line !== 'None');
+    if (bulletLines.length > 0) {
+        return bulletLines.slice(0, 3);
+    }
+    const inlineParts = section
+        .split(/[|;]/)
+        .map((part) => cleanLineValue(part))
+        .filter(Boolean)
+        .slice(0, 3);
+    return inlineParts.length > 0 ? inlineParts : fallback;
+}
+function sanitizeScalar(value, fallback) {
+    const cleaned = cleanLineValue(value)
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!cleaned
+        || cleaned.length > 240
+        || /```/.test(cleaned)
+        || /^function\s/i.test(cleaned)
+        || /return valid json/i.test(cleaned)
+        || /plain text responses/i.test(cleaned)
+        || /^here is /i.test(cleaned)
+        || /^these functions/i.test(cleaned)) {
+        return fallback;
+    }
+    return cleaned;
+}
+function sanitizeList(items, fallback) {
+    const cleaned = items
+        .map((item) => sanitizeScalar(item, ''))
+        .filter(Boolean)
+        .filter((item) => !/^(project goal|current direction|current focus|recent decisions|active errors|blockers|stack|next steps)\b/i.test(item))
+        .slice(0, 3);
+    return cleaned.length > 0 ? cleaned : fallback;
+}
+function parseSummaryFromText(text) {
+    const labels = [
+        'Project goal',
+        'Current direction',
+        'Current focus',
+        'Recent decisions',
+        'Blockers',
+        'Active errors',
+        'Active errors or blockers',
+        'Stack',
+        'Stack and key files',
+        'Next steps',
+    ];
+    const projectGoalSection = extractSection(text, 'Project goal', labels);
+    const currentDirectionSection = extractSection(text, 'Current direction', labels);
+    const currentFocusSection = extractSection(text, 'Current focus', labels);
+    const decisionsSection = extractSection(text, 'Recent decisions', labels);
+    const blockersSection = extractSection(text, 'Blockers', labels)
+        || extractSection(text, 'Active errors', labels)
+        || extractSection(text, 'Active errors or blockers', labels);
+    const stackSection = extractSection(text, 'Stack', labels)
+        || extractSection(text, 'Stack and key files', labels);
+    const nextStepsSection = extractSection(text, 'Next steps', labels);
+    const detectedSections = [
+        projectGoalSection,
+        currentDirectionSection,
+        currentFocusSection,
+        decisionsSection,
+        blockersSection,
+        stackSection,
+        nextStepsSection,
+    ].filter(Boolean).length;
+    if (detectedSections < 2) {
+        throw new Error('Model response did not contain structured summary headings.');
+    }
+    return {
+        projectGoal: sanitizeScalar(projectGoalSection, 'Unknown'),
+        currentDirection: sanitizeScalar(currentDirectionSection, 'Unknown'),
+        currentFocus: sanitizeScalar(currentFocusSection, 'Unknown'),
+        decisions: sanitizeList(extractBullets(decisionsSection, []), []),
+        blockers: sanitizeList(extractBullets(blockersSection, ['None']), ['None']),
+        stack: sanitizeScalar(stackSection, 'Unknown'),
+        nextSteps: sanitizeList(extractBullets(nextStepsSection, []), []),
+    };
+}
+function sanitizeSummary(summary) {
+    return {
+        projectGoal: sanitizeScalar(summary.projectGoal, 'Unknown'),
+        currentDirection: sanitizeScalar(summary.currentDirection, 'Unknown'),
+        currentFocus: sanitizeScalar(summary.currentFocus, 'Unknown'),
+        decisions: sanitizeList(summary.decisions, []),
+        blockers: sanitizeList(summary.blockers, ['None']),
+        stack: sanitizeScalar(summary.stack, 'Unknown'),
+        nextSteps: sanitizeList(summary.nextSteps, []),
+    };
+}
+function isWeakSummary(summary) {
+    return (summary.projectGoal === 'Unknown' &&
+        summary.currentDirection === 'Unknown' &&
+        summary.currentFocus === 'Unknown');
+}
+function parseSummary(text) {
+    const cleaned = text.trim();
+    const jsonStart = cleaned.indexOf('{');
+    const jsonEnd = cleaned.lastIndexOf('}');
+    if (jsonStart !== -1 && jsonEnd !== -1) {
+        const parsed = JSON.parse(cleaned.slice(jsonStart, jsonEnd + 1));
+        const validated = summarySchema.parse({
+            projectGoal: `${parsed.projectGoal ?? 'Unknown'}`.trim() || 'Unknown',
+            currentDirection: `${parsed.currentDirection ?? 'Unknown'}`.trim() || 'Unknown',
+            currentFocus: `${parsed.currentFocus ?? 'Unknown'}`.trim() || 'Unknown',
+            decisions: normaliseList(parsed.decisions, []),
+            blockers: normaliseList(parsed.blockers ?? parsed.errors, ['None']),
+            stack: `${parsed.stack ?? 'Unknown'}`.trim() || 'Unknown',
+            nextSteps: normaliseList(parsed.nextSteps, []),
+        });
+        const summary = sanitizeSummary(validated);
+        if (isWeakSummary(summary)) {
+            throw new Error('Model returned a generic or low-signal summary.');
+        }
+        return summary;
+    }
+    const parsedFromText = parseSummaryFromText(cleaned);
+    const hasAnyStructuredContent = parsedFromText.projectGoal !== 'Unknown'
+        || parsedFromText.currentDirection !== 'Unknown'
+        || parsedFromText.currentFocus !== 'Unknown'
+        || parsedFromText.decisions.length > 0
+        || parsedFromText.blockers[0] !== 'None'
+        || parsedFromText.stack !== 'Unknown'
+        || parsedFromText.nextSteps.length > 0;
+    if (!hasAnyStructuredContent) {
+        throw new Error('Model response did not contain parseable summary data.');
+    }
+    if (isWeakSummary(parsedFromText)) {
+        throw new Error('Model returned a generic or low-signal summary.');
+    }
+    return parsedFromText;
+}
+export async function summariseContent(content, config = {}) {
+    const fullConfig = config;
+    try {
+        const rawText = await callLLM(buildPrompt(content), fullConfig);
+        return parseSummary(rawText);
+    }
+    catch (error) {
+        if (fullConfig.provider === 'ollama' && error instanceof Error && error.name === 'TimeoutError') {
+            const rawText = await callLLM(buildFallbackPrompt(content), fullConfig);
+            return parseSummary(rawText);
+        }
+        throw error;
+    }
+}

package/dist/lib/project.js

@@ -0,0 +1,82 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+const EXCLUDED_NAMES = new Set([
+    'node_modules',
+    'dist',
+    '.git',
+    '.agents',
+    '.codex',
+    'AGENTS.md',
+    'package-lock.json',
+]);
+async function readIfPresent(filePath, limit = 1800) {
+    try {
+        const content = await fs.readFile(filePath, 'utf8');
+        return content.slice(0, limit).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function compactReadme(content) {
+    return content
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .filter((line) => !line.startsWith('```'))
+        .slice(0, 14)
+        .join('\n')
+        .slice(0, 900);
+}
+async function collectFiles(root, current = '', output = []) {
+    const target = path.join(root, current);
+    let entries = await fs.readdir(target, { withFileTypes: true });
+    entries = entries
+        .filter((entry) => !EXCLUDED_NAMES.has(entry.name))
+        .sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const relativePath = path.join(current, entry.name);
+        if (entry.isDirectory()) {
+            if (output.length >= 12) {
+                break;
+            }
+            await collectFiles(root, relativePath, output);
+            continue;
+        }
+        if (/\.(ts|tsx|js|jsx|json|md)$/i.test(entry.name)) {
+            output.push(relativePath);
+        }
+        if (output.length >= 12) {
+            break;
+        }
+    }
+    return output;
+}
+function formatPackageMetadata(content) {
+    if (!content) {
+        return '';
+    }
+    try {
+        const pkg = JSON.parse(content);
+        return [
+            `name: ${pkg.name ?? 'Unknown'}`,
+            `description: ${pkg.description ?? 'Unknown'}`,
+            `scripts: ${Object.keys(pkg.scripts ?? {}).slice(0, 8).join(', ') || 'Unknown'}`,
+            `dependencies: ${Object.keys(pkg.dependencies ?? {}).slice(0, 12).join(', ') || 'Unknown'}`,
+        ].join('\n');
+    }
+    catch {
+        return content;
+    }
+}
+export async function buildProjectGrounding(projectPath) {
+    const packageJson = await readIfPresent(path.join(projectPath, 'package.json'));
+    const readme = await readIfPresent(path.join(projectPath, 'README.md'));
+    const files = await collectFiles(projectPath);
+    const parts = [
+        packageJson ? `package.json:\n${formatPackageMetadata(packageJson)}` : '',
+        readme ? `README excerpt:\n${compactReadme(readme)}` : '',
+        files.length > 0 ? `Relevant files:\n${files.map((file) => `- ${file}`).join('\n')}` : '',
+    ].filter(Boolean);
+    return parts.join('\n\n');
+}