@kolmo/scout 0.1.0

package/dist/manifest/buildScoutManifest.js

@@ -0,0 +1,219 @@
+import path from 'path';
+import { existsSync } from 'fs';
+import { scanFiles } from '../scanners/fileScanner.js';
+import { scanPackages } from '../scanners/packageScanner.js';
+import { scanCsv } from '../scanners/csvScanner.js';
+import { scanExcel } from '../scanners/excelScanner.js';
+import { scanPython } from '../scanners/pythonScanner.js';
+import { scanNotebook } from '../scanners/notebookScanner.js';
+import { readFileContent } from '../scanners/contentScanner.js';
+import { detectFileType } from '../detectors/fileTypeDetector.js';
+import { detectAssetDetails } from '../detectors/assetDetector.js';
+import { detectProjectType } from '../detectors/projectTypeDetector.js';
+import { profileTabularData } from '../profilers/tabularProfiler.js';
+import { buildRepoSummary } from '../summarizers/repoSummary.js';
+import { buildSuggestedWorkflows, explainWorkflows } from '../workflows/workflowSuggestions.js';
+export async function buildScoutManifest(options) {
+    const cwd = options.dir ? path.resolve(options.dir) : process.cwd();
+    const projectName = path.basename(cwd);
+    const allFiles = await scanFiles(cwd);
+    const packages = await scanPackages(cwd);
+    const hasEnv = existsSync(path.join(cwd, '.env'));
+    const detectedFiles = [];
+    const fileContents = [];
+    const assetDetailsBySymbol = new Map();
+    const fileTypeReasons = [];
+    for (const relPath of allFiles) {
+        const absPath = path.join(cwd, relPath);
+        const ext = path.extname(relPath).toLowerCase();
+        const basename = path.basename(relPath);
+        let columns = [];
+        let signals = [];
+        let sampleRows = [];
+        const metadata = {};
+        try {
+            if (ext === '.csv') {
+                const result = await scanCsv(absPath);
+                columns = result.columns;
+                sampleRows = result.sampleRows;
+                metadata.rowCount = result.rowCount;
+                metadata.sampleRowCount = result.sampleRows.length;
+                metadata.profile = profileTabularData(columns, sampleRows);
+            }
+            else if (ext === '.xlsx' || ext === '.xls') {
+                const result = await scanExcel(absPath);
+                columns = result.columns;
+                sampleRows = result.sampleRows;
+                metadata.sheetNames = result.sheetNames;
+                metadata.sampleRowCount = result.sampleRows.length;
+                metadata.profile = profileTabularData(columns, sampleRows);
+            }
+            else if (ext === '.py') {
+                const result = await scanPython(absPath);
+                signals = result.signals;
+                metadata.importCount = result.imports.length;
+            }
+            else if (ext === '.ipynb') {
+                const result = await scanNotebook(absPath);
+                signals = result.signals;
+                metadata.cellCount = result.cellCount;
+                metadata.hasMarkdown = result.hasMarkdown;
+            }
+        }
+        catch {
+            // Keep Scout resilient on unreadable or malformed user files.
+        }
+        // Read file content for LLM analysis (unless --no-content)
+        if (!options.noContent) {
+            const fc = await readFileContent(absPath, ext);
+            if (fc) {
+                fileContents.push({ path: relPath, content: fc.content, truncated: fc.truncated });
+            }
+        }
+        const detected_type = detectFileType(basename, columns);
+        const fileAssetDetails = detectAssetDetails({
+            file: relPath,
+            filenames: [basename, relPath],
+            columnNames: columns,
+            textValues: signals,
+        });
+        const fileAssets = fileAssetDetails.map((asset) => asset.symbol);
+        for (const asset of fileAssetDetails) {
+            mergeAsset(assetDetailsBySymbol, asset);
+        }
+        const fileInfo = {
+            path: relPath,
+            extension: ext,
+            detected_type,
+            detected_assets: fileAssets,
+            columns,
+            signals,
+            metadata,
+        };
+        detectedFiles.push(fileInfo);
+        fileTypeReasons.push(explainFileType(fileInfo));
+    }
+    const projectType = detectProjectType(allFiles, packages);
+    const detailedAssets = Array.from(assetDetailsBySymbol.values()).sort((a, b) => a.symbol.localeCompare(b.symbol));
+    const detectedAssets = detailedAssets.map((asset) => asset.symbol);
+    const suggestedWorkflows = buildSuggestedWorkflows(projectType, detectedAssets);
+    const evidenceCitations = buildEvidenceCitations(detectedFiles);
+    const explanations = {
+        project_type_reasons: explainProjectType(projectType, allFiles, packages),
+        asset_evidence: detailedAssets,
+        file_type_reasons: fileTypeReasons,
+        workflow_reasons: explainWorkflows(suggestedWorkflows, detectedAssets, projectType),
+        evidence_citations: evidenceCitations,
+    };
+    const generatedSummary = buildRepoSummary({
+        projectName,
+        projectType,
+        detectedAssets,
+        detailedAssets,
+        detectedFiles,
+        detectedPackages: packages,
+        suggestedWorkflows,
+        evidenceCitations,
+    });
+    const manifest = {
+        schema_version: '0.1.0',
+        project_name: projectName,
+        created_by: 'kolmo-scout',
+        privacy_mode: options.noContent ? 'metadata_only' : 'content_excerpts',
+        project_type: projectType,
+        repo_summary: options.summary?.trim() ? normalizeSummary(options.summary) : generatedSummary,
+        summary_source: options.summary?.trim() ? 'provided' : 'generated',
+        detected_assets: detectedAssets,
+        detailed_assets: detailedAssets,
+        detected_files: detectedFiles,
+        detected_packages: packages,
+        suggested_workflows: suggestedWorkflows,
+        explanations,
+        file_contents: fileContents,
+        portfolio_name: options.portfolioName,
+    };
+    return { cwd, allFiles, hasEnv, manifest };
+}
+export function normalizeSummary(summary) {
+    return summary.replace(/\s+/g, ' ').trim();
+}
+function mergeAsset(assetDetailsBySymbol, asset) {
+    const existing = assetDetailsBySymbol.get(asset.symbol);
+    if (!existing) {
+        assetDetailsBySymbol.set(asset.symbol, asset);
+        return;
+    }
+    const seen = new Set(existing.evidence.map((item) => evidenceKey(item)));
+    for (const evidence of asset.evidence) {
+        const key = evidenceKey(evidence);
+        if (!seen.has(key)) {
+            existing.evidence.push(evidence);
+            seen.add(key);
+        }
+    }
+}
+function evidenceKey(evidence) {
+    return `${evidence.file ?? ''}:${evidence.source}:${evidence.value}:${evidence.pattern}`;
+}
+function explainProjectType(projectType, files, packages) {
+    if (projectType === 'python_analytics_project') {
+        return ['requirements.txt and Python files were detected.'];
+    }
+    if (projectType === 'notebook_research_project') {
+        return ['One or more Jupyter notebooks were detected.'];
+    }
+    if (projectType === 'frontend_project') {
+        return ['package.json plus React or Vite dependencies were detected.'];
+    }
+    if (projectType === 'fastapi_backend_project') {
+        return ['main.py plus FastAPI dependency were detected.'];
+    }
+    if (projectType === 'supabase_project') {
+        return ['A supabase/ project directory was detected.'];
+    }
+    if (projectType === 'data_folder_project') {
+        return ['More than half of scanned files are CSV or Excel files.'];
+    }
+    const fileText = files.length === 1 ? '1 file' : `${files.length} files`;
+    const packageText = [...packages.python, ...packages.node].length
+        ? 'with some dependencies'
+        : 'with no strong dependency signal';
+    return [`Scanned ${fileText} ${packageText}, but no specialized project pattern dominated.`];
+}
+function explainFileType(file) {
+    const evidence = [
+        ...file.columns.slice(0, 5).map((column) => `column:${column}`),
+        ...file.signals.slice(0, 5).map((signal) => `signal:${signal}`),
+    ];
+    const reasons = {
+        historical_prices: 'Date/timestamp and price-like columns were found.',
+        forward_curve: 'Maturity/expiry/contract and price/value columns were found.',
+        positions: 'Position, volume, book, or notional columns were found.',
+        risk_results: 'Risk, VaR, PnL, loss, or return fields were found.',
+        forecast_output: 'Forecast, prediction, yhat, or model output fields were found.',
+        news_events: 'Headline/title/source/url and published/date fields were found.',
+        notebook: 'The file is a Jupyter notebook.',
+        risk_model: 'The Python filename suggests risk, VaR, or PnL modelling.',
+        forecast_model: 'The Python filename suggests forecast or prediction modelling.',
+        unknown: 'No strong Scout file-type rule matched this file.',
+    };
+    return {
+        path: file.path,
+        detected_type: file.detected_type,
+        reason: reasons[file.detected_type] ?? reasons.unknown,
+        evidence,
+    };
+}
+function buildEvidenceCitations(files) {
+    return files
+        .filter((file) => file.columns.length > 0 || file.signals.length > 0 || file.detected_assets.length > 0)
+        .slice(0, 8)
+        .map((file) => {
+        const parts = [
+            ...file.columns.slice(0, 4),
+            ...file.signals.slice(0, 3).map((signal) => `signal:${signal}`),
+        ];
+        const evidence = parts.length ? parts.join(', ') : file.detected_assets.join(', ');
+        return `${file.path}: ${evidence}`;
+    });
+}

package/dist/profilers/tabularProfiler.d.ts

@@ -0,0 +1,15 @@
+export interface TabularProfile {
+    sample_row_count: number;
+    column_count: number;
+    date_column?: string;
+    frequency_guess?: string;
+    latest_date?: string;
+    stale_days?: number;
+    is_stale?: boolean;
+    missingness_estimate?: number;
+    tenor_column?: string;
+    tenor_count?: number;
+    detected_tenors?: string[];
+    tenor_gaps?: string[];
+}
+export declare function profileTabularData(columns: string[], rows: Array<Record<string, unknown>>): TabularProfile;

package/dist/profilers/tabularProfiler.js

@@ -0,0 +1,131 @@
+import { parseTenor } from '../taxonomy/energyTaxonomy.js';
+const STALE_DAYS = 45;
+export function profileTabularData(columns, rows) {
+    const profile = {
+        sample_row_count: rows.length,
+        column_count: columns.length,
+    };
+    if (columns.length === 0 || rows.length === 0) {
+        return profile;
+    }
+    profile.missingness_estimate = estimateMissingness(columns, rows);
+    const dateColumn = guessDateColumn(columns, rows);
+    if (dateColumn) {
+        profile.date_column = dateColumn;
+        const dates = rows
+            .map((row) => parseDate(row[dateColumn]))
+            .filter((date) => date != null)
+            .sort((a, b) => a.getTime() - b.getTime());
+        if (dates.length > 0) {
+            const latestDate = dates[dates.length - 1];
+            profile.latest_date = latestDate.toISOString().slice(0, 10);
+            profile.frequency_guess = guessFrequency(dates);
+            profile.stale_days = Math.max(0, Math.floor((Date.now() - latestDate.getTime()) / 86_400_000));
+            profile.is_stale = profile.stale_days > STALE_DAYS;
+        }
+    }
+    const tenorColumn = guessTenorColumn(columns, rows);
+    if (tenorColumn) {
+        const parsedTenors = rows
+            .map((row) => parseTenor(String(row[tenorColumn] ?? '')))
+            .filter((tenor) => tenor != null);
+        if (parsedTenors.length > 0) {
+            const labels = Array.from(new Set(parsedTenors.map((tenor) => tenor.label))).sort();
+            profile.tenor_column = tenorColumn;
+            profile.tenor_count = labels.length;
+            profile.detected_tenors = labels.slice(0, 24);
+            profile.tenor_gaps = detectTenorGaps(parsedTenors);
+        }
+    }
+    return profile;
+}
+function estimateMissingness(columns, rows) {
+    let missing = 0;
+    let total = 0;
+    for (const row of rows) {
+        for (const column of columns) {
+            total += 1;
+            const value = row[column];
+            if (value == null || String(value).trim() === '') {
+                missing += 1;
+            }
+        }
+    }
+    return total === 0 ? 0 : Number((missing / total).toFixed(3));
+}
+function guessDateColumn(columns, rows) {
+    const named = columns.find((column) => /(^|_|\s)(date|timestamp|ts|asof|as_of)(_|$|\s)/i.test(column));
+    if (named)
+        return named;
+    return columns.find((column) => {
+        const parsed = rows.slice(0, 10).filter((row) => parseDate(row[column]) != null).length;
+        return parsed >= Math.max(2, Math.ceil(Math.min(rows.length, 10) * 0.6));
+    });
+}
+function guessTenorColumn(columns, rows) {
+    const named = columns.find((column) => /(tenor|maturity|contract|expiry|delivery|period)/i.test(column));
+    if (named)
+        return named;
+    return columns.find((column) => {
+        const parsed = rows.slice(0, 10).filter((row) => parseTenor(String(row[column] ?? '')) != null).length;
+        return parsed >= Math.max(2, Math.ceil(Math.min(rows.length, 10) * 0.5));
+    });
+}
+function parseDate(value) {
+    if (value instanceof Date && !Number.isNaN(value.getTime()))
+        return value;
+    if (typeof value !== 'string' && typeof value !== 'number')
+        return null;
+    const date = new Date(value);
+    return Number.isNaN(date.getTime()) ? null : date;
+}
+function guessFrequency(dates) {
+    if (dates.length < 3)
+        return 'unknown';
+    const diffs = dates
+        .slice(1)
+        .map((date, index) => Math.round((date.getTime() - dates[index].getTime()) / 86_400_000))
+        .filter((days) => days > 0);
+    if (diffs.length === 0)
+        return 'unknown';
+    const median = diffs.sort((a, b) => a - b)[Math.floor(diffs.length / 2)];
+    if (median <= 2)
+        return 'daily';
+    if (median >= 5 && median <= 9)
+        return 'weekly';
+    if (median >= 27 && median <= 35)
+        return 'monthly';
+    if (median >= 80 && median <= 100)
+        return 'quarterly';
+    if (median >= 350 && median <= 380)
+        return 'annual';
+    return 'irregular';
+}
+function detectTenorGaps(tenors) {
+    const gaps = [];
+    const relativeMonths = tenors
+        .filter((tenor) => tenor.kind === 'relative_month' && tenor.sequence != null)
+        .map((tenor) => Number(tenor.sequence))
+        .sort((a, b) => a - b);
+    for (let index = 1; index < relativeMonths.length; index += 1) {
+        const prev = relativeMonths[index - 1];
+        const current = relativeMonths[index];
+        for (let missing = prev + 1; missing < current; missing += 1) {
+            gaps.push(`M${missing}`);
+        }
+    }
+    const quarters = tenors
+        .filter((tenor) => tenor.kind === 'quarter' && tenor.year != null && tenor.quarter != null)
+        .map((tenor) => Number(tenor.year) * 4 + Number(tenor.quarter))
+        .sort((a, b) => a - b);
+    for (let index = 1; index < quarters.length; index += 1) {
+        const prev = quarters[index - 1];
+        const current = quarters[index];
+        for (let missing = prev + 1; missing < current; missing += 1) {
+            const year = Math.floor((missing - 1) / 4);
+            const quarter = ((missing - 1) % 4) + 1;
+            gaps.push(`Q${quarter}-${String(year).slice(-2)}`);
+        }
+    }
+    return Array.from(new Set(gaps)).slice(0, 24);
+}

package/dist/scanners/contentScanner.d.ts

@@ -0,0 +1,6 @@
+export interface FileContent {
+    path: string;
+    content: string;
+    truncated: boolean;
+}
+export declare function readFileContent(absPath: string, ext: string): Promise<FileContent | null>;

package/dist/scanners/contentScanner.js

@@ -0,0 +1,22 @@
+import fs from 'fs/promises';
+const MAX_BYTES = 8_192;
+const READABLE_EXTENSIONS = new Set(['.py', '.ipynb', '.md', '.txt', '.rst', '.r', '.jl', '.sql']);
+export async function readFileContent(absPath, ext) {
+    if (!READABLE_EXTENSIONS.has(ext.toLowerCase()))
+        return null;
+    try {
+        const buffer = await fs.readFile(absPath);
+        // Skip binary files — check for null bytes in first 512 bytes
+        const probe = buffer.slice(0, 512);
+        for (let i = 0; i < probe.length; i++) {
+            if (probe[i] === 0)
+                return null;
+        }
+        const truncated = buffer.length > MAX_BYTES;
+        const content = buffer.slice(0, MAX_BYTES).toString('utf8');
+        return { path: absPath, content, truncated };
+    }
+    catch {
+        return null;
+    }
+}

package/dist/scanners/csvScanner.d.ts

@@ -0,0 +1,5 @@
+export declare function scanCsv(filepath: string): Promise<{
+    columns: string[];
+    rowCount: number;
+    sampleRows: Array<Record<string, unknown>>;
+}>;

package/dist/scanners/csvScanner.js

@@ -0,0 +1,26 @@
+import { open } from 'fs/promises';
+import Papa from 'papaparse';
+const CSV_SNIFF_BYTES = 20_480;
+export async function scanCsv(filepath) {
+    let fileHandle;
+    try {
+        fileHandle = await open(filepath, 'r');
+        const buffer = Buffer.alloc(CSV_SNIFF_BYTES);
+        const { bytesRead } = await fileHandle.read(buffer, 0, CSV_SNIFF_BYTES, 0);
+        const snippet = buffer.subarray(0, bytesRead).toString('utf-8');
+        const result = Papa.parse(snippet, {
+            header: true,
+            skipEmptyLines: true,
+            preview: 25,
+        });
+        const columns = result.meta.fields ?? [];
+        const rowCount = result.data.length;
+        return { columns, rowCount, sampleRows: result.data };
+    }
+    catch {
+        return { columns: [], rowCount: 0, sampleRows: [] };
+    }
+    finally {
+        await fileHandle?.close();
+    }
+}

package/dist/scanners/excelScanner.d.ts

@@ -0,0 +1,5 @@
+export declare function scanExcel(filepath: string): Promise<{
+    columns: string[];
+    sheetNames: string[];
+    sampleRows: Array<Record<string, unknown>>;
+}>;

package/dist/scanners/excelScanner.js

@@ -0,0 +1,25 @@
+import { readFile } from 'fs/promises';
+import * as XLSX from 'xlsx';
+export async function scanExcel(filepath) {
+    try {
+        const buffer = await readFile(filepath);
+        const workbook = XLSX.read(buffer, { type: 'buffer', sheetRows: 26 });
+        const sheetNames = workbook.SheetNames;
+        if (sheetNames.length === 0) {
+            return { columns: [], sheetNames: [], sampleRows: [] };
+        }
+        const firstSheet = workbook.Sheets[sheetNames[0]];
+        const rows = XLSX.utils.sheet_to_json(firstSheet, { header: 1 });
+        const sampleRows = XLSX.utils.sheet_to_json(firstSheet, {
+            defval: '',
+        });
+        const headerRow = rows[0];
+        const columns = Array.isArray(headerRow)
+            ? headerRow.map((v) => String(v ?? '').trim()).filter(Boolean)
+            : [];
+        return { columns, sheetNames, sampleRows };
+    }
+    catch {
+        return { columns: [], sheetNames: [], sampleRows: [] };
+    }
+}

package/dist/scanners/fileScanner.d.ts

@@ -0,0 +1 @@
+export declare function scanFiles(rootDir: string): Promise<string[]>;

package/dist/scanners/fileScanner.js

@@ -0,0 +1,24 @@
+import fg from 'fast-glob';
+const IGNORE_PATTERNS = [
+    '**/node_modules/**',
+    '**/.git/**',
+    '**/dist/**',
+    '**/build/**',
+    '**/.venv/**',
+    '**/venv/**',
+    '**/__pycache__/**',
+    '**/.next/**',
+    '**/coverage/**',
+    '**/kolmo.config.json',
+    '**/*.pyc',
+    '**/.DS_Store',
+];
+export async function scanFiles(rootDir) {
+    const files = await fg('**/*', {
+        cwd: rootDir,
+        ignore: IGNORE_PATTERNS,
+        dot: true,
+        onlyFiles: true,
+    });
+    return files.sort();
+}

package/dist/scanners/notebookScanner.d.ts

@@ -0,0 +1,5 @@
+export declare function scanNotebook(filepath: string): Promise<{
+    cellCount: number;
+    hasMarkdown: boolean;
+    signals: string[];
+}>;

package/dist/scanners/notebookScanner.js

@@ -0,0 +1,32 @@
+import { readFile } from 'fs/promises';
+const SIGNAL_KEYWORDS = [
+    'var',
+    'pnl',
+    'risk',
+    'forecast',
+    'predict',
+    'backtest',
+    'portfolio',
+    'hedge',
+];
+export async function scanNotebook(filepath) {
+    try {
+        const content = await readFile(filepath, 'utf-8');
+        const notebook = JSON.parse(content);
+        if (!Array.isArray(notebook.cells)) {
+            return { cellCount: 0, hasMarkdown: false, signals: [] };
+        }
+        const cellCount = notebook.cells.length;
+        const hasMarkdown = notebook.cells.some((c) => c.cell_type === 'markdown');
+        const codeCells = notebook.cells.filter((c) => c.cell_type === 'code');
+        const codeText = codeCells
+            .map((c) => (Array.isArray(c.source) ? c.source.join('') : c.source ?? ''))
+            .join('\n')
+            .toLowerCase();
+        const signals = SIGNAL_KEYWORDS.filter((kw) => codeText.includes(kw));
+        return { cellCount, hasMarkdown, signals };
+    }
+    catch {
+        return { cellCount: 0, hasMarkdown: false, signals: [] };
+    }
+}

package/dist/scanners/packageScanner.d.ts

@@ -0,0 +1,4 @@
+export declare function scanPackages(rootDir: string): Promise<{
+    python: string[];
+    node: string[];
+}>;

package/dist/scanners/packageScanner.js

@@ -0,0 +1,46 @@
+import { readFile } from 'fs/promises';
+import { existsSync } from 'fs';
+import path from 'path';
+export async function scanPackages(rootDir) {
+    const python = [];
+    const node = [];
+    // Scan requirements.txt
+    const reqPath = path.join(rootDir, 'requirements.txt');
+    if (existsSync(reqPath)) {
+        try {
+            const content = await readFile(reqPath, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                // Strip version specifiers: e.g. "fastapi>=0.100.0" → "fastapi"
+                const name = trimmed.split(/[>=<!;[\s]/)[0].trim();
+                if (name)
+                    python.push(name.toLowerCase());
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    // Scan package.json
+    const pkgPath = path.join(rootDir, 'package.json');
+    if (existsSync(pkgPath)) {
+        try {
+            const content = await readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(content);
+            const deps = {
+                ...pkg.dependencies,
+                ...pkg.devDependencies,
+            };
+            for (const name of Object.keys(deps)) {
+                node.push(name);
+            }
+        }
+        catch {
+            // ignore
+        }
+    }
+    return { python: [...new Set(python)], node: [...new Set(node)] };
+}

package/dist/scanners/pythonScanner.d.ts

@@ -0,0 +1,4 @@
+export declare function scanPython(filepath: string): Promise<{
+    imports: string[];
+    signals: string[];
+}>;

package/dist/scanners/pythonScanner.js

@@ -0,0 +1,30 @@
+import { readFile } from 'fs/promises';
+const SIGNAL_KEYWORDS = [
+    'var',
+    'pnl',
+    'risk',
+    'forecast',
+    'predict',
+    'backtest',
+    'portfolio',
+    'hedge',
+];
+export async function scanPython(filepath) {
+    try {
+        const content = await readFile(filepath, 'utf-8');
+        const lines = content.split('\n');
+        const imports = lines
+            .filter((line) => {
+            const trimmed = line.trim();
+            return trimmed.startsWith('import ') || trimmed.startsWith('from ');
+        })
+            .map((line) => line.trim());
+        const uniqueImports = [...new Set(imports)];
+        const contentLower = content.toLowerCase();
+        const signals = SIGNAL_KEYWORDS.filter((kw) => contentLower.includes(kw));
+        return { imports: uniqueImports, signals };
+    }
+    catch {
+        return { imports: [], signals: [] };
+    }
+}

package/dist/summarizers/repoSummary.d.ts

@@ -0,0 +1,16 @@
+import type { ScoutAssetInfo, ScoutFileInfo } from '../types.js';
+interface RepoSummaryInput {
+    projectName: string;
+    projectType: string;
+    detectedAssets: string[];
+    detailedAssets?: ScoutAssetInfo[];
+    detectedFiles: ScoutFileInfo[];
+    detectedPackages: {
+        python: string[];
+        node: string[];
+    };
+    suggestedWorkflows: string[];
+    evidenceCitations?: string[];
+}
+export declare function buildRepoSummary(input: RepoSummaryInput): string;
+export {};