@wangzhizhi/remi 0.0.1-alpha

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

@@ -0,0 +1,123 @@
+import { existsSync, lstatSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { dirname, join, parse, relative, resolve } from 'node:path';
+const projectInstructionsFileNames = ['AGENTS.md', 'AGENT.md', 'CLAUDE.md', 'REMI.md'];
+const maxInstructionFiles = 8;
+const maxInstructionFileBytes = 64 * 1024;
+const maxInstructionFileChars = 32_000;
+const maxInstructionTotalChars = 64_000;
+export function buildProjectInstructionsContext(cwd) {
+    const candidates = discoverProjectInstructionFiles(cwd);
+    const loadedFiles = [];
+    const skippedFiles = [];
+    const sections = [];
+    let remainingChars = maxInstructionTotalChars;
+    for (const candidate of candidates) {
+        if (loadedFiles.length >= maxInstructionFiles || remainingChars <= 0) {
+            skippedFiles.push(`${candidate} (project instruction budget exhausted)`);
+            continue;
+        }
+        try {
+            const linkStat = lstatSync(candidate);
+            if (linkStat.isSymbolicLink()) {
+                skippedFiles.push(`${candidate} (symbolic links are not auto-loaded)`);
+                continue;
+            }
+            const stat = statSync(candidate);
+            if (!stat.isFile()) {
+                skippedFiles.push(`${candidate} (not a regular file)`);
+                continue;
+            }
+            if (stat.size > maxInstructionFileBytes) {
+                skippedFiles.push(`${candidate} (${stat.size} bytes exceeds ${maxInstructionFileBytes} byte limit)`);
+                continue;
+            }
+            const raw = readFileSync(candidate, 'utf8');
+            const text = clampText(raw.trim(), Math.min(maxInstructionFileChars, remainingChars));
+            if (text.length === 0) {
+                skippedFiles.push(`${candidate} (empty)`);
+                continue;
+            }
+            loadedFiles.push(candidate);
+            remainingChars -= text.length;
+            sections.push([`### ${displayInstructionPath(cwd, candidate)}`, '', text].join('\n'));
+        }
+        catch (error) {
+            skippedFiles.push(`${candidate} (${safeInstructionError(error)})`);
+        }
+    }
+    if (sections.length === 0) {
+        return {
+            source: skippedFiles.length > 0 ? `project instructions unavailable (${skippedFiles.length} skipped)` : 'project instructions not found',
+            loadedFiles,
+            skippedFiles,
+        };
+    }
+    const skippedLine = skippedFiles.length > 0 ? [`Skipped: ${skippedFiles.length} file(s).`, ''] : [];
+    return {
+        content: [
+            '## Project Instructions',
+            '',
+            `These files are loaded automatically from the current working directory and its parents: ${projectInstructionsFileNames.join(', ')}. Follow them when they apply to the current task.`,
+            '',
+            ...skippedLine,
+            ...sections,
+        ].join('\n'),
+        source: `project instructions (${loadedFiles.length} loaded${skippedFiles.length > 0 ? `, ${skippedFiles.length} skipped` : ''})`,
+        loadedFiles,
+        skippedFiles,
+    };
+}
+function discoverProjectInstructionFiles(cwd) {
+    const dirs = [];
+    let current = resolve(cwd);
+    const root = parse(current).root;
+    while (true) {
+        dirs.push(current);
+        if (current === root) {
+            break;
+        }
+        const parent = dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    const seen = new Set();
+    const files = [];
+    for (const dir of dirs.reverse()) {
+        for (const fileName of projectInstructionsFileNames) {
+            const candidate = join(dir, fileName);
+            if (!existsSync(candidate)) {
+                continue;
+            }
+            const key = canonicalInstructionPath(candidate);
+            if (seen.has(key)) {
+                continue;
+            }
+            seen.add(key);
+            files.push(candidate);
+        }
+    }
+    return files;
+}
+function canonicalInstructionPath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return resolve(path);
+    }
+}
+function displayInstructionPath(cwd, path) {
+    const relativePath = relative(cwd, path);
+    return relativePath.length === 0 || relativePath.startsWith('..') ? path : relativePath;
+}
+function clampText(text, maxChars) {
+    if (text.length <= maxChars) {
+        return text;
+    }
+    return `${text.slice(0, Math.max(0, maxChars - 52)).trimEnd()}\n[Project instruction content truncated by Remi.]`;
+}
+function safeInstructionError(error) {
+    return error instanceof Error ? error.message : String(error);
+}

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

@@ -0,0 +1,98 @@
+import { readFileSync } from 'node:fs';
+export const defaultResponseStyleId = 'remi';
+export const responseStylePresets = [
+    {
+        id: 'remi',
+        label: 'Remi',
+        description: 'Default coding-agent style: direct, practical, and low-noise.',
+        instructions: [
+            'Do not introduce yourself unless the user asks who you are.',
+            'Do not use emoji, cheerleading, or generic small talk.',
+        ],
+    },
+    {
+        id: 'brief',
+        label: 'Brief',
+        description: 'Shortest useful answer; minimal explanation.',
+        instructions: [
+            'Use the shortest answer that still handles the request.',
+            'Prefer one or two concise paragraphs.',
+            'Avoid background explanation unless it changes the action.',
+        ],
+    },
+    {
+        id: 'explain',
+        label: 'Explain',
+        description: 'Adds reasoning, assumptions, and tradeoffs when useful.',
+        instructions: [
+            'Explain key reasoning and assumptions clearly.',
+            'Mention tradeoffs when there are meaningful implementation choices.',
+            'Keep the explanation structured and avoid filler.',
+        ],
+    },
+    {
+        id: 'mentor',
+        label: 'Mentor',
+        description: 'Learning-oriented style with steps and why they matter.',
+        instructions: [
+            'Teach the approach step by step.',
+            'Explain why each important step exists.',
+            'Keep examples concrete and avoid long lectures.',
+        ],
+    },
+    {
+        id: 'minimal',
+        label: 'Minimal',
+        description: 'Ultra-short replies for saving tokens.',
+        instructions: [
+            'Use the fewest words possible while still answering the request.',
+            'For completed work, prefer a terse confirmation in the latest user message language when no detail is needed; for Chinese, use "搞定。".',
+            'Do not include background, recap, alternatives, or next steps unless the user asks or a blocker must be surfaced.',
+            'For failures, risks, or unverified work, still say so in one short sentence.',
+        ],
+    },
+];
+export function isResponseStyleId(value) {
+    return responseStylePresets.some(style => style.id === value);
+}
+export function resolveResponseStyle(styleId) {
+    return responseStylePresets.find(style => style.id === styleId) ?? responseStylePresets[0];
+}
+let cachedBaseSystemPromptTemplate;
+export function buildBaseSystemPrompt(styleId, language) {
+    return `${readBaseSystemPromptTemplate()}\n\n## Response Language\n\n${buildResponseLanguageSystemPrompt(language)}\n\n## Response Style\n\n${buildResponseStyleSystemPrompt(styleId)}`;
+}
+export function buildResponseLanguageSystemPrompt(language) {
+    if (language === 'zh-Hans') {
+        return [
+            '- Use Simplified Chinese for all user-facing assistant prose, visible plan items, brief transition text, blockers, and final answers.',
+            '- Do not use English filler or mixed-language lead-ins such as "Let me", "First", "I will", or "I need to" in Chinese responses; write those clauses in Chinese instead.',
+            '- Keep code identifiers, file paths, commands, API names, compiler output, and required literals unchanged.',
+            '- Do not switch to English merely because runtime instructions, tool names, or file comments are in English.',
+        ].join('\n');
+    }
+    if (language === 'en') {
+        return [
+            '- Use English for all user-facing assistant prose, visible plan items, brief transition text, blockers, and final answers.',
+            '- Keep code identifiers, file paths, commands, API names, compiler output, and required literals unchanged.',
+        ].join('\n');
+    }
+    return [
+        '- Match the latest user message language for all user-facing assistant prose, visible plan items, brief transition text, blockers, and final answers.',
+        '- If the latest user message is Chinese, use Simplified Chinese.',
+        '- For Chinese responses, do not use English filler or mixed-language lead-ins such as "Let me", "First", "I will", or "I need to"; write those clauses in Chinese instead.',
+        '- Keep code identifiers, file paths, commands, API names, compiler output, and required literals unchanged.',
+    ].join('\n');
+}
+export function buildResponseStyleSystemPrompt(styleId) {
+    const style = resolveResponseStyle(styleId);
+    const defaultStyle = resolveResponseStyle(defaultResponseStyleId);
+    const instructions = style.id === defaultStyle.id
+        ? defaultStyle.instructions
+        : [...defaultStyle.instructions, ...style.instructions];
+    return instructions.map(instruction => `- ${instruction}`).join('\n');
+}
+function readBaseSystemPromptTemplate() {
+    cachedBaseSystemPromptTemplate ??= readFileSync(new URL('../../../prompt/base-system.md', import.meta.url), 'utf8').trim();
+    return cachedBaseSystemPromptTemplate;
+}

package/node_modules/@remi/core/package.json

@@ -0,0 +1,8 @@
+{
+  "name": "@remi/core",
+  "version": "0.0.1-alpha",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js"
+  }
+}