@wangzhizhi/remi 0.0.1-alpha

package/node_modules/@remi/core/dist/directoryOverview.js

@@ -0,0 +1,359 @@
+const overviewIntentPattern = /(看|看看|检查|瞅|浏览|了解|列|列出|有什么|包含|目录|文件夹|folder|directory|contents|what.*in)/i;
+const directoryWords = ['文件夹', '目录', 'folder', 'directory'];
+const desktopBookPattern = /(?:桌面|desktop).*book|book.*(?:文件夹|目录|folder|directory)/i;
+export async function buildDirectoryOverviewPrelude(options) {
+    const targetPath = detectDirectoryOverviewTarget(options.input, options.env);
+    if (!targetPath) {
+        return undefined;
+    }
+    const toolCalls = [];
+    const run = async (toolName, input) => {
+        const call = {
+            id: `prelude-${toolCalls.length + 1}`,
+            toolName,
+            input,
+        };
+        const outcome = await options.executor.execute({
+            call,
+            context: {
+                cwd: options.cwd,
+                sessionId: options.sessionId,
+                maxOutputBytes: 128 * 1024,
+                ...(options.signal ? { signal: options.signal } : {}),
+                permissionMode: 'readonly',
+                allowedReadRoots: allowedReadRoots(options.cwd, options.env),
+            },
+        });
+        toolCalls.push({ call, result: outcome.result });
+        return outcome.result;
+    };
+    const topLevel = await run('list_files', { path: targetPath, includeHidden: true, maxEntries: 200 });
+    const entries = parseEntries(topLevel);
+    const guide = selectGuideFile(entries);
+    if (guide) {
+        await run('read_file', { path: guide, maxBytes: 12_000 });
+    }
+    for (const directory of selectImportantDirectories(entries)) {
+        await run('list_files', { path: directory, maxEntries: 120 });
+    }
+    const contentDirectory = selectContentDirectory(entries);
+    if (contentDirectory) {
+        await run('glob', { path: contentDirectory, pattern: '**/*.md', maxResults: 300 });
+    }
+    const summaryFile = selectSummaryFile(entries);
+    if (summaryFile) {
+        await run('read_file', { path: summaryFile, maxBytes: 16_000 });
+    }
+    return {
+        targetPath,
+        toolCalls,
+        messages: [formatDirectoryOverviewContext(targetPath, toolCalls)],
+    };
+}
+function detectDirectoryOverviewTarget(input, env) {
+    const normalized = input.trim();
+    if (!overviewIntentPattern.test(normalized)) {
+        return undefined;
+    }
+    if (desktopBookPattern.test(normalized) && env.HOME) {
+        return `${env.HOME}/Desktop/book`;
+    }
+    const absoluteMatch = normalized.match(/(\/[^\s，。！？!?]+(?:\/[^\s，。！？!?]+)*)/);
+    if (absoluteMatch?.[1]) {
+        return absoluteMatch[1];
+    }
+    const quoted = normalized.match(/["'`“”‘’]([^"'`“”‘’]+)["'`“”‘’]/)?.[1];
+    if (quoted && looksLikeDirectoryReference(normalized, quoted)) {
+        return quoted;
+    }
+    const relative = normalized.match(/(?:看看|看|检查|浏览|列出|list|inspect)\s+([A-Za-z0-9._~/-]+)/i)?.[1];
+    if (relative) {
+        return relative;
+    }
+    return undefined;
+}
+function looksLikeDirectoryReference(input, target) {
+    return directoryWords.some(word => input.toLowerCase().includes(word)) || target.includes('/') || target.includes('\\');
+}
+function formatDirectoryOverviewContext(targetPath, toolCalls) {
+    const sections = [
+        '## Directory Overview Prelude',
+        '',
+        `Target directory: ${targetPath}`,
+        '',
+        'Remi already performed a bounded read-only overview before answering. Use this context to produce a project-level explanation, not just a top-level listing.',
+        '',
+        'Answer rules:',
+        '- Separate confirmed facts from filename-based inference.',
+        '- Mention counts, latest-looking files, guide files, summaries, indexes, archives, and hidden config when present.',
+        '- If a guide or summary file was read, use it to explain what the project is for.',
+        '- Do not claim certainty about contents you did not inspect.',
+        '- Prefer a compact tree view first when the user asks what a directory contains, then add a short "core files" explanation.',
+        '',
+        formatDirectoryTreeFacts(targetPath, toolCalls),
+        '',
+        ...toolCalls.flatMap(({ call, result }) => [
+            `### ${formatToolCallTitle(call)}`,
+            result.ok ? compactToolOutput(result.output) : `Error: ${result.error.code}: ${result.error.message}`,
+            '',
+        ]),
+    ];
+    return { role: 'system', content: sections.join('\n') };
+}
+function formatDirectoryTreeFacts(targetPath, toolCalls) {
+    const listedDirectories = parseListedDirectories(toolCalls);
+    const topLevel = listedDirectories[0];
+    if (!topLevel) {
+        return '### Suggested tree view\nNo directory listing facts are available.';
+    }
+    const rootPath = topLevel.path;
+    const rootName = basename(rootPath === '.' ? targetPath : rootPath);
+    const childListings = new Map(listedDirectories.slice(1).map(directory => [directory.path, directory]));
+    const globMatches = parseGlobMatches(toolCalls);
+    const contentDirectories = new Map();
+    for (const match of globMatches) {
+        const parent = dirname(match);
+        contentDirectories.set(parent, [...(contentDirectories.get(parent) ?? []), match]);
+    }
+    const lines = ['### Suggested tree view', '', 'Use this tree as factual scaffolding for the answer:', '', `${rootName}/`];
+    const entries = orderEntriesForTree(topLevel.entries);
+    entries.forEach((entry, index) => {
+        const isLast = index === entries.length - 1;
+        appendTreeEntry(lines, entry, {
+            isLast,
+            prefix: '',
+            rootPath,
+            childListings,
+            contentDirectories,
+        });
+    });
+    const fileEntries = entries.filter(entry => entry.type === 'file');
+    if (fileEntries.length > 0) {
+        lines.push('', 'Core top-level files:');
+        for (const file of fileEntries.slice(0, 8)) {
+            lines.push(`- ${basename(file.path)}${file.sizeBytes !== undefined ? ` (${formatBytes(file.sizeBytes)})` : ''}`);
+        }
+    }
+    return lines.join('\n');
+}
+function parseListedDirectories(toolCalls) {
+    return toolCalls
+        .flatMap(({ call, result }) => {
+        if (call.toolName !== 'list_files' || !result.ok) {
+            return [];
+        }
+        const parsed = parseToolOutput(result.output);
+        const path = typeof parsed?.['path'] === 'string' ? parsed['path'] : '';
+        const entries = Array.isArray(parsed?.['entries']) ? parsed['entries'].filter(isDirectoryEntry) : [];
+        return [{ path, entries }];
+    })
+        .filter(directory => directory.path && directory.entries.length > 0);
+}
+function parseGlobMatches(toolCalls) {
+    return toolCalls
+        .flatMap(({ call, result }) => {
+        if (call.toolName !== 'glob' || !result.ok) {
+            return [];
+        }
+        const parsed = parseToolOutput(result.output);
+        return Array.isArray(parsed?.['matches']) ? parsed['matches'].filter((item) => typeof item === 'string') : [];
+    });
+}
+function appendTreeEntry(lines, entry, options) {
+    const connector = options.isLast ? '└── ' : '├── ';
+    const childPrefix = `${options.prefix}${options.isLast ? '    ' : '│   '}`;
+    const name = `${basename(entry.path)}${entry.type === 'directory' ? '/' : ''}`;
+    const annotation = annotationForEntry(entry, options.contentDirectories.get(entry.path));
+    lines.push(`${options.prefix}${connector}${name}${annotation ? `  # ${annotation}` : ''}`);
+    if (entry.type !== 'directory') {
+        return;
+    }
+    const contentMatches = options.contentDirectories.get(entry.path);
+    if (contentMatches && contentMatches.length > 0) {
+        appendContentSamples(lines, childPrefix, contentMatches);
+        return;
+    }
+    const childListing = options.childListings.get(entry.path);
+    if (!childListing) {
+        return;
+    }
+    const children = orderEntriesForTree(childListing.entries).slice(0, 8);
+    children.forEach((child, index) => {
+        appendTreeEntry(lines, child, {
+            ...options,
+            isLast: index === children.length - 1,
+            prefix: childPrefix,
+        });
+    });
+}
+function appendContentSamples(lines, prefix, matches) {
+    const sorted = [...matches].sort((left, right) => left.localeCompare(right));
+    const samples = sorted.length <= 4 ? sorted : [sorted[0], sorted[1], '...', sorted[sorted.length - 1]].filter((item) => Boolean(item));
+    samples.forEach((sample, index) => {
+        const isLast = index === samples.length - 1;
+        const connector = isLast ? '└── ' : '├── ';
+        lines.push(`${prefix}${connector}${sample === '...' ? '...' : basename(sample)}`);
+    });
+}
+function annotationForEntry(entry, contentMatches) {
+    if (contentMatches && contentMatches.length > 0) {
+        const markdownCount = contentMatches.filter(match => match.toLowerCase().endsWith('.md')).length;
+        return markdownCount > 0 ? `${markdownCount} markdown files` : `${contentMatches.length} matched files`;
+    }
+    if (entry.type === 'file' && entry.sizeBytes !== undefined) {
+        return formatBytes(entry.sizeBytes);
+    }
+    const lowerName = basename(entry.path).toLowerCase();
+    if (lowerName === '.claude') {
+        return 'local Claude configuration';
+    }
+    if (lowerName === 'old' || lowerName === 'archive') {
+        return 'archive or old version';
+    }
+    if (lowerName === 'rag') {
+        return 'retrieval index data';
+    }
+    if (lowerName === 'summaries') {
+        return 'summary files';
+    }
+    return '';
+}
+function orderEntriesForTree(entries) {
+    return [...entries].sort((left, right) => {
+        if (left.type === 'directory' && right.type !== 'directory') {
+            return -1;
+        }
+        if (left.type !== 'directory' && right.type === 'directory') {
+            return 1;
+        }
+        return basename(left.path).localeCompare(basename(right.path));
+    });
+}
+function formatToolCallTitle(call) {
+    const path = typeof call.input['path'] === 'string' ? call.input['path'] : undefined;
+    const pattern = typeof call.input['pattern'] === 'string' ? call.input['pattern'] : undefined;
+    if (call.toolName === 'glob' && pattern) {
+        return `Glob ${path ?? '.'} ${pattern}`;
+    }
+    const target = path ?? pattern ?? JSON.stringify(call.input);
+    const label = call.toolName === 'list_files' ? 'List' : call.toolName === 'read_file' ? 'Read' : call.toolName;
+    return `${label} ${target}`;
+}
+function compactToolOutput(output) {
+    const parsed = parseToolOutput(output);
+    if (!parsed) {
+        return truncate(output, 8_000);
+    }
+    if (Array.isArray(parsed['entries'])) {
+        const entries = parsed['entries'].filter(isDirectoryEntry);
+        const path = typeof parsed['path'] === 'string' ? parsed['path'] : '';
+        const files = entries.filter(entry => entry.type === 'file');
+        const directories = entries.filter(entry => entry.type === 'directory');
+        return [
+            `${entries.length} entries${path ? ` in ${path}` : ''}.`,
+            directories.length > 0 ? `Directories: ${directories.map(entry => entry.path).join(', ')}` : '',
+            files.length > 0 ? `Files: ${files.map(entry => entry.path).join(', ')}` : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (Array.isArray(parsed['matches'])) {
+        const matches = parsed['matches'].filter((item) => typeof item === 'string');
+        return `${matches.length} matched paths:\n${matches.slice(0, 120).join('\n')}${matches.length > 120 ? '\n[truncated]' : ''}`;
+    }
+    if (typeof parsed['content'] === 'string') {
+        const path = typeof parsed['path'] === 'string' ? parsed['path'] : '';
+        return `${path ? `File: ${path}\n` : ''}${truncate(parsed['content'], 12_000)}`;
+    }
+    return truncate(JSON.stringify(parsed), 8_000);
+}
+function parseEntries(result) {
+    if (!result.ok) {
+        return [];
+    }
+    const parsed = parseToolOutput(result.output);
+    return Array.isArray(parsed?.['entries']) ? parsed['entries'].filter(isDirectoryEntry) : [];
+}
+function parseToolOutput(output) {
+    try {
+        const parsed = JSON.parse(output);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed) ? parsed : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function selectGuideFile(entries) {
+    const priority = ['AGENTS.md', 'AGENT.md', 'CLAUDE.md', 'REMI.md', 'README.md', 'PLAN.md'];
+    for (const name of priority) {
+        const found = entries.find(entry => entry.type === 'file' && basename(entry.path) === name);
+        if (found) {
+            return found.path;
+        }
+    }
+    return undefined;
+}
+function selectImportantDirectories(entries) {
+    const importantNames = ['.claude', 'summaries', 'rag', 'old', 'archive', 'docs'];
+    return entries
+        .filter(entry => entry.type === 'directory' && importantNames.includes(basename(entry.path).toLowerCase()))
+        .map(entry => entry.path)
+        .slice(0, 4);
+}
+function selectContentDirectory(entries) {
+    const candidates = ['chapters', 'src', 'apps', 'packages', 'docs'];
+    for (const name of candidates) {
+        const found = entries.find(entry => entry.type === 'directory' && basename(entry.path).toLowerCase() === name);
+        if (found) {
+            return found.path;
+        }
+    }
+    return undefined;
+}
+function selectSummaryFile(entries) {
+    const summariesDir = entries.find(entry => entry.type === 'directory' && basename(entry.path).toLowerCase() === 'summaries');
+    return summariesDir ? `${summariesDir.path}/chapter_summaries.md` : undefined;
+}
+function isDirectoryEntry(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const entry = value;
+    return typeof entry.path === 'string' && typeof entry.type === 'string';
+}
+function basename(path) {
+    return path.split('/').filter(Boolean).at(-1) ?? path;
+}
+function dirname(path) {
+    const normalized = path.replace(/\/+$/, '');
+    const slashIndex = normalized.lastIndexOf('/');
+    if (slashIndex < 0) {
+        return '.';
+    }
+    if (slashIndex === 0) {
+        return '/';
+    }
+    return normalized.slice(0, slashIndex);
+}
+function formatBytes(bytes) {
+    if (bytes >= 1024 * 1024) {
+        return `${formatByteNumber(bytes / (1024 * 1024))}MB`;
+    }
+    if (bytes >= 1024) {
+        return `${formatByteNumber(bytes / 1024)}KB`;
+    }
+    return `${bytes}B`;
+}
+function formatByteNumber(value) {
+    return value >= 10 ? String(Math.round(value)) : value.toFixed(1);
+}
+function truncate(text, maxChars) {
+    return text.length > maxChars ? `${text.slice(0, maxChars - 14)}\n[truncated]` : text;
+}
+function allowedReadRoots(cwd, env) {
+    const roots = [cwd];
+    if (env.HOME && env.HOME !== cwd) {
+        roots.push(env.HOME);
+    }
+    return roots;
+}