@wangzhizhi/remi 0.0.1-alpha

package/node_modules/@remi/llm/package.json

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

package/node_modules/@remi/memory/dist/index.js

@@ -0,0 +1,312 @@
+import { existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+export const memoryPackageName = '@remi/memory';
+export const memoryTypes = ['user', 'project', 'feedback', 'reference'];
+const defaultRecallLimit = 5;
+const defaultMaxBodyChars = 6_000;
+export function memoryDir(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'memory');
+}
+export function memoriesDir(cwd = process.cwd()) {
+    return join(memoryDir(cwd), 'memories');
+}
+export function memoryIndexPath(cwd = process.cwd()) {
+    return join(memoryDir(cwd), 'index.json');
+}
+export function memoryFilePath(cwd, id) {
+    return join(memoriesDir(cwd), `${assertSafeMemoryId(id)}.md`);
+}
+export function createMemory(cwd, input) {
+    const id = assertSafeMemoryId(input.id ?? randomUUID());
+    const now = input.now ?? new Date().toISOString();
+    const description = input.description.replace(/\s+/g, ' ').trim();
+    const body = input.body.trim();
+    if (description.length === 0) {
+        throw new Error('Memory description is required');
+    }
+    if (body.length === 0) {
+        throw new Error('Memory body is required');
+    }
+    if (containsSensitiveText(`${description}\n${body}`)) {
+        throw new Error('Memory content appears to contain sensitive data');
+    }
+    const record = {
+        id,
+        type: input.type,
+        scope: input.scope ?? 'project',
+        description,
+        createdAt: now,
+        updatedAt: now,
+        useCount: 0,
+        body,
+    };
+    ensureMemoryDirs(cwd);
+    writeMemoryRecord(cwd, record);
+    refreshMemoryIndex(cwd, now);
+    return record;
+}
+export function readMemoryIndex(cwd) {
+    const path = memoryIndexPath(cwd);
+    if (!existsSync(path)) {
+        return { version: 1, updatedAt: '', memories: [] };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (!isMemoryIndex(parsed)) {
+            return { version: 1, updatedAt: '', memories: [] };
+        }
+        return parsed;
+    }
+    catch {
+        return { version: 1, updatedAt: '', memories: [] };
+    }
+}
+export function refreshMemoryIndex(cwd, now = new Date().toISOString()) {
+    ensureMemoryDirs(cwd);
+    const index = {
+        version: 1,
+        updatedAt: now,
+        memories: scanMemoryHeaders(cwd).sort((left, right) => right.updatedAt.localeCompare(left.updatedAt)),
+    };
+    writeFileSync(memoryIndexPath(cwd), `${JSON.stringify(index, null, 2)}\n`);
+    return index;
+}
+export function scanMemoryHeaders(cwd) {
+    const dir = memoriesDir(cwd);
+    if (!existsSync(dir)) {
+        return [];
+    }
+    return readdirSync(dir, { withFileTypes: true })
+        .filter(entry => entry.isFile() && entry.name.endsWith('.md'))
+        .flatMap(entry => {
+        const parsed = readMemoryHeader(join(dir, entry.name));
+        return parsed ? [parsed] : [];
+    });
+}
+export function readMemory(cwd, id) {
+    const path = memoryFilePath(cwd, id);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    const parsed = parseMemoryFile(readFileSync(path, 'utf8'));
+    if (!parsed || containsSensitiveText(`${parsed.description}\n${parsed.body}`)) {
+        return undefined;
+    }
+    return parsed;
+}
+export function recallRelevantMemories(cwd, query, options = {}) {
+    const limit = normalizeLimit(options.limit, defaultRecallLimit);
+    const maxBodyChars = normalizeLimit(options.maxBodyChars, defaultMaxBodyChars);
+    const index = refreshMemoryIndex(cwd);
+    if (limit === 0 || maxBodyChars === 0 || query.trim().length === 0) {
+        return emptyMemoryRecall(query, limit, index.memories.length);
+    }
+    const scored = index.memories
+        .map(memory => ({ memory, score: scoreMemory(query, memory) }))
+        .filter(item => item.score > 0)
+        .sort((left, right) => {
+        if (right.score !== left.score) {
+            return right.score - left.score;
+        }
+        return right.memory.updatedAt.localeCompare(left.memory.updatedAt);
+    });
+    const memories = [];
+    let remainingChars = maxBodyChars;
+    for (const item of scored) {
+        if (memories.length >= limit || remainingChars <= 0) {
+            break;
+        }
+        const record = readMemory(cwd, item.memory.id);
+        if (!record) {
+            continue;
+        }
+        const body = truncateMemoryBody(record.body, remainingChars);
+        remainingChars -= body.length;
+        memories.push({
+            ...record,
+            body,
+            reason: `matched ${item.score} query token${item.score === 1 ? '' : 's'} in memory description`,
+        });
+    }
+    return {
+        memories,
+        trace: {
+            query,
+            limit,
+            manifestCount: index.memories.length,
+            selected: memories.map(memory => ({
+                id: memory.id,
+                type: memory.type,
+                description: memory.description,
+                reason: memory.reason,
+            })),
+        },
+    };
+}
+export function emptyMemoryRecall(query, limit = defaultRecallLimit, manifestCount = 0) {
+    return {
+        memories: [],
+        trace: {
+            query,
+            limit,
+            manifestCount,
+            selected: [],
+        },
+    };
+}
+export function recordMemoryUse(cwd, ids, now = new Date().toISOString()) {
+    const uniqueIds = [...new Set(ids.map(id => assertSafeMemoryId(id)))];
+    for (const id of uniqueIds) {
+        const record = readMemory(cwd, id);
+        if (!record) {
+            continue;
+        }
+        writeMemoryRecord(cwd, {
+            ...record,
+            lastUsedAt: now,
+            useCount: record.useCount + 1,
+        });
+    }
+    if (uniqueIds.length > 0) {
+        refreshMemoryIndex(cwd, now);
+    }
+}
+function ensureMemoryDirs(cwd) {
+    mkdirSync(memoriesDir(cwd), { recursive: true });
+}
+function readMemoryHeader(path) {
+    const parsed = parseMemoryFile(readFileSync(path, 'utf8'));
+    if (!parsed) {
+        return undefined;
+    }
+    const { body: _body, ...metadata } = parsed;
+    return metadata;
+}
+function parseMemoryFile(content) {
+    const lines = content.split(/\r?\n/);
+    if (lines[0]?.trim() !== '---') {
+        return undefined;
+    }
+    const endIndex = lines.findIndex((line, index) => index > 0 && line.trim() === '---');
+    if (endIndex <= 0) {
+        return undefined;
+    }
+    const metadata = parseFrontmatter(lines.slice(1, endIndex));
+    if (!metadata) {
+        return undefined;
+    }
+    const body = lines.slice(endIndex + 1).join('\n').trim();
+    return { ...metadata, body };
+}
+function parseFrontmatter(lines) {
+    const fields = new Map();
+    for (const line of lines) {
+        const separatorIndex = line.indexOf(':');
+        if (separatorIndex <= 0) {
+            continue;
+        }
+        const key = line.slice(0, separatorIndex).trim();
+        const value = line.slice(separatorIndex + 1).trim();
+        fields.set(key, value);
+    }
+    const id = fields.get('id');
+    const type = fields.get('type');
+    const scope = fields.get('scope') || 'project';
+    const description = fields.get('description');
+    const createdAt = fields.get('createdAt');
+    const updatedAt = fields.get('updatedAt');
+    const useCount = Number.parseInt(fields.get('useCount') ?? '0', 10);
+    const lastUsedAt = fields.get('lastUsedAt');
+    if (!id ||
+        !isMemoryType(type) ||
+        !isMemoryScope(scope) ||
+        !description ||
+        !createdAt ||
+        !updatedAt ||
+        !Number.isFinite(useCount)) {
+        return undefined;
+    }
+    const entry = {
+        id: assertSafeMemoryId(id),
+        type,
+        scope,
+        description,
+        createdAt,
+        updatedAt,
+        useCount,
+    };
+    return lastUsedAt ? { ...entry, lastUsedAt } : entry;
+}
+function writeMemoryRecord(cwd, record) {
+    const lines = [
+        '---',
+        `id: ${record.id}`,
+        `type: ${record.type}`,
+        `scope: ${record.scope}`,
+        `description: ${record.description}`,
+        `createdAt: ${record.createdAt}`,
+        `updatedAt: ${record.updatedAt}`,
+        `lastUsedAt: ${record.lastUsedAt ?? ''}`,
+        `useCount: ${record.useCount}`,
+        '---',
+        '',
+        record.body.trim(),
+        '',
+    ];
+    writeFileSync(memoryFilePath(cwd, record.id), lines.join('\n'));
+}
+function isMemoryIndex(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const index = value;
+    return index.version === 1 && typeof index.updatedAt === 'string' && Array.isArray(index.memories);
+}
+function isMemoryType(value) {
+    return typeof value === 'string' && memoryTypes.includes(value);
+}
+function isMemoryScope(value) {
+    return value === 'project' || value === 'user';
+}
+function scoreMemory(query, memory) {
+    const queryTokens = new Set(tokenize(query));
+    if (queryTokens.size === 0) {
+        return 0;
+    }
+    const memoryTokens = new Set(tokenize(`${memory.type} ${memory.description} ${memory.id}`));
+    let score = 0;
+    for (const token of queryTokens) {
+        if (memoryTokens.has(token)) {
+            score += 1;
+        }
+    }
+    return score;
+}
+function tokenize(text) {
+    return [...text.toLowerCase().matchAll(/[\p{L}\p{N}_-]+/gu)].map(match => match[0] ?? '').filter(Boolean);
+}
+function normalizeLimit(value, fallback) {
+    if (value === undefined || !Number.isFinite(value)) {
+        return fallback;
+    }
+    return Math.max(0, Math.floor(value));
+}
+function truncateMemoryBody(body, maxChars) {
+    if (body.length <= maxChars) {
+        return body;
+    }
+    if (maxChars <= 48) {
+        return body.slice(0, maxChars);
+    }
+    return `${body.slice(0, maxChars - 31)}\n[Memory body truncated.]`;
+}
+function containsSensitiveText(text) {
+    return /(api[_-]?key|access[_-]?token|private[_-]?key|BEGIN [A-Z ]*PRIVATE KEY|sk-[A-Za-z0-9]{12,})/i.test(text);
+}
+function assertSafeMemoryId(id) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(id)) {
+        throw new Error(`Invalid memory id: ${id}`);
+    }
+    return id;
+}

package/node_modules/@remi/memory/package.json

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

package/node_modules/@remi/permissions/dist/index.js

@@ -0,0 +1,90 @@
+export const permissionsPackageName = '@remi/permissions';
+export function evaluateToolPermission(request) {
+    if (request.policy.requirements.length === 0) {
+        return {
+            status: 'deny',
+            reason: `Tool ${request.toolName} declares no permission requirements.`,
+            requirements: [],
+        };
+    }
+    if (request.policy.mode === 'deny') {
+        return {
+            status: 'deny',
+            reason: request.policy.reason,
+            requirements: request.policy.requirements,
+        };
+    }
+    if (request.policy.mode === 'bypass-required') {
+        return {
+            status: 'deny',
+            reason: `Tool ${request.toolName} requires explicit bypass mode.`,
+            requirements: request.policy.requirements,
+        };
+    }
+    if (request.policy.mode === 'allow') {
+        return {
+            status: 'allow',
+            reason: request.policy.reason,
+            requirements: request.policy.requirements,
+        };
+    }
+    return {
+        status: 'ask',
+        reason: request.policy.reason,
+        requirements: request.policy.requirements,
+    };
+}
+export function summarizeToolInput(input, maxLength = 240) {
+    const stable = JSON.stringify(sortRecord(input));
+    if (stable.length <= maxLength) {
+        return stable;
+    }
+    return `${stable.slice(0, Math.max(0, maxLength - 3))}...`;
+}
+export function autoReviewToolPermission(request) {
+    if (request.toolName !== 'execute_shell' || !request.command) {
+        return undefined;
+    }
+    if (request.command.segments.length === 0) {
+        return undefined;
+    }
+    const reviewable = request.command.segments.every(isAutoReviewAllowedShellSegment);
+    if (!reviewable) {
+        return undefined;
+    }
+    return {
+        status: 'allow',
+        reason: 'Auto-review approved a bounded local validation command inside the current sandbox.',
+        requirements: request.policy.requirements,
+    };
+}
+function isAutoReviewAllowedShellSegment(segment) {
+    const [firstArg, secondArg] = segment.args;
+    if (segment.command === 'pwd') {
+        return segment.args.length === 0;
+    }
+    if (segment.command === 'go') {
+        return firstArg === 'test' || firstArg === 'vet';
+    }
+    if (segment.command === 'pnpm' || segment.command === 'npm' || segment.command === 'yarn') {
+        if (firstArg === 'test' || firstArg === 'typecheck' || firstArg === 'build' || firstArg === 'lint') {
+            return true;
+        }
+        return firstArg === 'run' && ['test', 'typecheck', 'build', 'lint'].includes(secondArg ?? '');
+    }
+    if (segment.command === 'git') {
+        return ['status', 'diff', 'log'].includes(firstArg ?? '');
+    }
+    return false;
+}
+function sortRecord(value) {
+    if (Array.isArray(value)) {
+        return value.map(item => sortRecord(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    return Object.fromEntries(Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => [key, sortRecord(item)]));
+}

package/node_modules/@remi/permissions/package.json

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