@wangzhizhi/remi 0.0.1-alpha

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

@@ -0,0 +1,370 @@
+import { appendFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join, relative } from 'node:path';
+import { randomUUID } from 'node:crypto';
+export const sessionsPackageName = '@remi/sessions';
+export function createSessionId() {
+    return randomUUID();
+}
+export function sessionsDir(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'sessions');
+}
+export function artifactsDir(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'artifacts');
+}
+export function toolResultArtifactsDir(cwd, sessionId) {
+    return join(artifactsDir(cwd), 'tool-results', safeArtifactSegment(sessionId));
+}
+export function sessionPath(cwd, sessionId) {
+    return join(sessionsDir(cwd), `${sessionId}.jsonl`);
+}
+export function sessionSummaryPath(cwd, sessionId) {
+    return join(sessionsDir(cwd), `${safeArtifactSegment(sessionId)}.summary.md`);
+}
+export function sessionPermissionRulesPath(cwd, sessionId) {
+    return join(sessionsDir(cwd), `${sessionId}.permissions.json`);
+}
+export function sessionIndexPath(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'sessions', 'index.json');
+}
+export function activeSessionPath(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'session.json');
+}
+export function projectInputHistoryPath(cwd = process.cwd()) {
+    return join(cwd, '.agent', 'input-history.json');
+}
+export function sessionExists(cwd, sessionId) {
+    return existsSync(sessionPath(cwd, sessionId));
+}
+export function readActiveSessionId(cwd = process.cwd()) {
+    const path = activeSessionPath(cwd);
+    if (!existsSync(path)) {
+        return undefined;
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (typeof parsed.sessionId !== 'string' || !sessionExists(cwd, parsed.sessionId)) {
+            return undefined;
+        }
+        return parsed.sessionId;
+    }
+    catch {
+        return undefined;
+    }
+}
+export function writeActiveSessionId(cwd, sessionId) {
+    ensureAgentDir(cwd);
+    writeFileSync(activeSessionPath(cwd), `${JSON.stringify({ sessionId, updatedAt: new Date().toISOString() }, null, 2)}\n`);
+}
+export function writeToolResultArtifact(cwd, sessionId, input) {
+    const createdAt = input.now ?? new Date().toISOString();
+    const contentType = input.contentType ?? 'application/json';
+    const id = `${safeArtifactSegment(input.toolName)}-${safeArtifactSegment(input.callId)}`;
+    const directory = toolResultArtifactsDir(cwd, sessionId);
+    const path = join(directory, `${id}.json`);
+    const bytes = Buffer.byteLength(input.content, 'utf8');
+    const record = {
+        type: 'tool_result',
+        sessionId,
+        callId: input.callId,
+        toolName: input.toolName,
+        createdAt,
+        contentType,
+        bytes,
+        content: input.content,
+    };
+    mkdirSync(directory, { recursive: true });
+    writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 });
+    return {
+        id,
+        kind: 'tool-result',
+        path: relative(cwd, path),
+        bytes,
+        contentType,
+        createdAt,
+    };
+}
+export function createNewSession(cwd = process.cwd()) {
+    const sessionId = createSessionId();
+    ensureSessionDirs(cwd);
+    writeFileSync(sessionPath(cwd, sessionId), '');
+    writeActiveSessionId(cwd, sessionId);
+    upsertSessionIndex(cwd, sessionId);
+    return sessionId;
+}
+export function resolveActiveSessionId(cwd = process.cwd()) {
+    return readActiveSessionId(cwd) ?? createNewSession(cwd);
+}
+export function readSessionEvents(cwd, sessionId) {
+    const path = sessionPath(cwd, sessionId);
+    if (!existsSync(path)) {
+        return [];
+    }
+    return readFileSync(path, 'utf8')
+        .split('\n')
+        .map(line => line.trim())
+        .filter(Boolean)
+        .flatMap(line => {
+        try {
+            const parsed = JSON.parse(line);
+            return isSessionEvent(parsed) ? [parsed] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+}
+export function readSessionUserInputs(cwd, sessionId) {
+    return readSessionEvents(cwd, sessionId)
+        .filter((event) => event.type === 'user')
+        .map(event => event.content);
+}
+export function readProjectInputHistory(cwd = process.cwd(), limit = 200) {
+    return readProjectInputHistoryEntries(cwd)
+        .slice(-Math.max(0, limit))
+        .map(entry => entry.content);
+}
+export function appendProjectInputHistory(cwd, content, sessionId) {
+    const normalized = content.trim();
+    if (normalized.length === 0) {
+        return;
+    }
+    const current = readProjectInputHistoryEntries(cwd);
+    const last = current[current.length - 1];
+    if (last?.content === normalized) {
+        return;
+    }
+    const timestamp = new Date().toISOString();
+    const nextEntries = [
+        ...current,
+        {
+            content: normalized,
+            timestamp,
+            ...(sessionId ? { sessionId } : {}),
+        },
+    ].slice(-200);
+    writeProjectInputHistory(cwd, {
+        updatedAt: timestamp,
+        entries: nextEntries,
+    });
+}
+export function readSessionPermissionRules(cwd, sessionId) {
+    const path = sessionPermissionRulesPath(cwd, sessionId);
+    if (!existsSync(path)) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (!isSessionPermissionRulesFile(parsed) || parsed.sessionId !== sessionId) {
+            return [];
+        }
+        return parsed.rules;
+    }
+    catch {
+        return [];
+    }
+}
+export function writeSessionPermissionRules(cwd, sessionId, rules) {
+    ensureSessionDirs(cwd);
+    const validRules = rules.filter(isSessionPermissionAllowRule);
+    const payload = {
+        sessionId,
+        updatedAt: new Date().toISOString(),
+        rules: validRules,
+    };
+    writeFileSync(sessionPermissionRulesPath(cwd, sessionId), `${JSON.stringify(payload, null, 2)}\n`);
+}
+export function createSessionStore(cwd = process.cwd(), sessionId = createSessionId()) {
+    ensureSessionDirs(cwd);
+    const path = sessionPath(cwd, sessionId);
+    if (!existsSync(path)) {
+        writeFileSync(path, '');
+    }
+    writeActiveSessionId(cwd, sessionId);
+    upsertSessionIndex(cwd, sessionId);
+    return {
+        sessionId,
+        sessionPath: path,
+        append(event) {
+            const timestamp = new Date().toISOString();
+            const record = {
+                ...event,
+                sessionId,
+                timestamp,
+            };
+            appendFileSync(path, `${JSON.stringify(record)}\n`);
+            upsertSessionIndex(cwd, sessionId, record);
+        },
+    };
+}
+function ensureAgentDir(cwd) {
+    mkdirSync(join(cwd, '.agent'), { recursive: true });
+}
+function ensureSessionDirs(cwd) {
+    ensureAgentDir(cwd);
+    mkdirSync(sessionsDir(cwd), { recursive: true });
+}
+function safeArtifactSegment(value) {
+    const safe = value.replace(/[^A-Za-z0-9._-]/g, '-').replace(/-+/g, '-').replace(/^-|-$/g, '');
+    return (safe.length > 0 ? safe : 'artifact').slice(0, 120);
+}
+function readProjectInputHistoryEntries(cwd) {
+    const path = projectInputHistoryPath(cwd);
+    if (!existsSync(path)) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        if (isProjectInputHistoryFile(parsed)) {
+            return parsed.entries;
+        }
+        if (Array.isArray(parsed)) {
+            return parsed
+                .filter((entry) => typeof entry === 'string')
+                .map(content => ({ content, timestamp: new Date(0).toISOString() }));
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+}
+function writeProjectInputHistory(cwd, history) {
+    ensureAgentDir(cwd);
+    writeFileSync(projectInputHistoryPath(cwd), `${JSON.stringify(history, null, 2)}\n`);
+}
+function readSessionIndex(cwd) {
+    const path = sessionIndexPath(cwd);
+    if (!existsSync(path)) {
+        return [];
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(path, 'utf8'));
+        return Array.isArray(parsed) ? parsed.filter(isSessionIndexEntry) : [];
+    }
+    catch {
+        return [];
+    }
+}
+function writeSessionIndex(cwd, entries) {
+    ensureSessionDirs(cwd);
+    writeFileSync(sessionIndexPath(cwd), `${JSON.stringify(entries, null, 2)}\n`);
+}
+function upsertSessionIndex(cwd, sessionId, event) {
+    const path = sessionPath(cwd, sessionId);
+    const now = event?.timestamp ?? new Date().toISOString();
+    const entries = readSessionIndex(cwd);
+    const existing = entries.find(entry => entry.sessionId === sessionId);
+    const title = existing?.title ?? (event?.type === 'user' ? titleFromInput(event.content) : undefined);
+    const nextEntry = {
+        sessionId,
+        sessionPath: path,
+        cwd,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        ...(event ? { lastMessageAt: now } : existing?.lastMessageAt ? { lastMessageAt: existing.lastMessageAt } : {}),
+        ...(title ? { title } : {}),
+    };
+    const nextEntries = [nextEntry, ...entries.filter(entry => entry.sessionId !== sessionId)];
+    writeSessionIndex(cwd, nextEntries);
+}
+function titleFromInput(input) {
+    const title = input.replace(/\s+/g, ' ').trim().slice(0, 80);
+    return title.length > 0 ? title : undefined;
+}
+function isSessionIndexEntry(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const entry = value;
+    return typeof entry.sessionId === 'string' && typeof entry.sessionPath === 'string' && typeof entry.cwd === 'string';
+}
+function isSessionPermissionRulesFile(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const file = value;
+    return typeof file.sessionId === 'string' && typeof file.updatedAt === 'string' && Array.isArray(file.rules) && file.rules.every(isSessionPermissionAllowRule);
+}
+function isProjectInputHistoryFile(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const file = value;
+    return typeof file.updatedAt === 'string' && Array.isArray(file.entries) && file.entries.every(isProjectInputHistoryEntry);
+}
+function isProjectInputHistoryEntry(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const entry = value;
+    return typeof entry.content === 'string' && typeof entry.timestamp === 'string' && optionalString(entry.sessionId);
+}
+function isSessionPermissionAllowRule(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const rule = value;
+    if (rule.kind === 'shell-prefix') {
+        return typeof rule.prefix === 'string' && optionalString(rule.cwd) && optionalString(rule.createdAt);
+    }
+    if (rule.kind === 'filesystem-write-root') {
+        return (typeof rule.root === 'string' &&
+            optionalString(rule.createdAt) &&
+            (rule.operations === undefined || (Array.isArray(rule.operations) && rule.operations.every(isSessionPermissionFilesystemOperation))));
+    }
+    return false;
+}
+function isSessionPermissionFilesystemOperation(value) {
+    return value === 'create' || value === 'write' || value === 'edit' || value === 'delete';
+}
+function optionalString(value) {
+    return value === undefined || typeof value === 'string';
+}
+function isSessionEvent(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const event = value;
+    if (typeof event.sessionId !== 'string' || typeof event.timestamp !== 'string') {
+        return false;
+    }
+    if (event.type === 'user') {
+        return typeof event.content === 'string';
+    }
+    if (event.type === 'system') {
+        return typeof event.content === 'string' && (event.level === 'info' || event.level === 'warn' || event.level === 'error');
+    }
+    if (event.type === 'assistant') {
+        return typeof event.content === 'string' && Boolean(event.model && typeof event.model === 'object');
+    }
+    if (event.type === 'tool_call') {
+        return typeof event.callId === 'string' && typeof event.toolName === 'string' && Boolean(event.input && typeof event.input === 'object');
+    }
+    if (event.type === 'tool_result') {
+        return (typeof event.callId === 'string' &&
+            typeof event.toolName === 'string' &&
+            typeof event.ok === 'boolean' &&
+            typeof event.summary === 'string' &&
+            (event.artifact === undefined || isSessionArtifactRef(event.artifact)));
+    }
+    if (event.type === 'compact') {
+        return (typeof event.summary === 'string' &&
+            typeof event.estimatedTokens === 'number' &&
+            typeof event.sourceEventCount === 'number' &&
+            (event.trigger === undefined || event.trigger === 'manual' || event.trigger === 'auto' || event.trigger === 'reactive') &&
+            (event.strategy === undefined || event.strategy === 'deterministic' || event.strategy === 'model'));
+    }
+    return false;
+}
+function isSessionArtifactRef(value) {
+    if (!value || typeof value !== 'object') {
+        return false;
+    }
+    const artifact = value;
+    return (typeof artifact.id === 'string' &&
+        artifact.kind === 'tool-result' &&
+        typeof artifact.path === 'string' &&
+        typeof artifact.bytes === 'number' &&
+        (artifact.contentType === 'application/json' || artifact.contentType === 'text/plain') &&
+        typeof artifact.createdAt === 'string');
+}

package/node_modules/@remi/sessions/package.json

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

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

@@ -0,0 +1,273 @@
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve } from 'node:path';
+export const skillsPackageName = '@remi/skills';
+const defaultMaxDescriptionChars = 240;
+const defaultMaxSkillContentChars = 24_000;
+export function globalSkillsDir(homeDir = homedir()) {
+    return join(homeDir, '.remi', 'skills');
+}
+export function projectSkillsDirs(cwd = process.cwd(), homeDir = homedir()) {
+    const start = resolve(cwd);
+    const home = resolve(homeDir);
+    const dirs = [];
+    let current = start;
+    while (true) {
+        dirs.push(join(current, 'skills'));
+        if (current === home || current === dirname(current)) {
+            break;
+        }
+        current = dirname(current);
+    }
+    return dirs.reverse();
+}
+export function skillDiscoveryRoots(options = {}) {
+    const cwd = options.cwd ?? process.cwd();
+    const homeDir = options.homeDir ?? homedir();
+    const roots = [
+        { source: 'global', path: globalSkillsDir(homeDir), exists: false },
+        ...projectSkillsDirs(cwd, homeDir).map(path => ({ source: 'project', path, exists: false })),
+    ];
+    const seen = new Set();
+    return roots
+        .map(root => ({ ...root, path: resolve(root.path), exists: existsSync(root.path) }))
+        .filter(root => {
+        const key = safeRealpath(root.path) ?? root.path;
+        if (seen.has(key)) {
+            return false;
+        }
+        seen.add(key);
+        return true;
+    });
+}
+export function loadSkillIndex(options = {}) {
+    const disabled = new Set((options.disabled ?? []).map(normalizeSkillName).filter(Boolean));
+    const roots = skillDiscoveryRoots(options);
+    const byName = new Map();
+    for (const root of roots) {
+        if (!root.exists) {
+            continue;
+        }
+        for (const entry of loadSkillsFromRoot(root, disabled, options.maxDescriptionChars ?? defaultMaxDescriptionChars)) {
+            byName.set(normalizeSkillName(entry.name), entry);
+        }
+    }
+    return {
+        roots,
+        skills: Array.from(byName.values()).sort(compareSkills),
+    };
+}
+export function loadSkillContent(options) {
+    const index = loadSkillIndex(options);
+    const target = normalizeSkillName(options.name);
+    const skill = index.skills.find(candidate => normalizeSkillName(candidate.name) === target);
+    if (!skill || !skill.enabled) {
+        return undefined;
+    }
+    const parsed = parseSkillFile(readFileSync(skill.filePath, 'utf8'));
+    return {
+        ...skill,
+        content: truncateText(parsed.body.trim(), options.maxContentChars ?? defaultMaxSkillContentChars),
+    };
+}
+export function formatSkillIndexContext(index, loadedSkills = []) {
+    const enabledSkills = index.skills.filter(skill => skill.enabled);
+    if (enabledSkills.length === 0 && loadedSkills.length === 0) {
+        return undefined;
+    }
+    const lines = [
+        '## Remi Skills',
+        '',
+        'Progressive disclosure: this section lists discovered skills from `skills/<name>/SKILL.md` and `~/.remi/skills/<name>/SKILL.md`. Only the skill index is loaded by default; full skill instructions appear below only when the user explicitly selects a skill or the model loads it with the `load_skill` tool.',
+        'When a listed skill semantically matches the user request, call `load_skill` with the skill name before reading files, editing files, running commands, or answering about the task. If the match is ambiguous, do not load a skill. Do not claim that a skill was used unless full instructions have been loaded.',
+    ];
+    if (enabledSkills.length > 0) {
+        lines.push('', 'Available skill index:');
+        for (const skill of enabledSkills) {
+            const when = skill.whenToUse ? ` Use when: ${skill.whenToUse}` : '';
+            const aliases = skill.aliases?.length ? ` Aliases: ${skill.aliases.join(', ')}.` : '';
+            const keywords = skill.keywords?.length ? ` Keywords: ${skill.keywords.join(', ')}.` : '';
+            lines.push(`- ${skill.name} (${skill.source}): ${skill.description} Path: ${skill.filePath}.${aliases}${keywords}${when}`);
+        }
+    }
+    if (loadedSkills.length > 0) {
+        lines.push('', 'Loaded skill instructions:');
+        for (const skill of loadedSkills) {
+            lines.push('', `### ${skill.name}`, `Source: ${skill.filePath}`, skill.content);
+        }
+    }
+    return lines.join('\n');
+}
+export function buildSkillInvocationPrompt(skill, args = []) {
+    const userArgs = args.join(' ').trim();
+    return [
+        `Use the Remi skill \`${skill.name}\` for this turn.`,
+        `Skill source: ${skill.filePath}`,
+        userArgs ? `User arguments: ${userArgs}` : 'No extra user arguments were provided.',
+        '',
+        'Skill instructions:',
+        skill.content,
+    ].join('\n');
+}
+function loadSkillsFromRoot(root, disabled, maxDescriptionChars) {
+    let entries;
+    try {
+        entries = readdirSync(root.path, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    return entries
+        .filter(entry => entry.isDirectory() || entry.isSymbolicLink())
+        .map(entry => loadSkillFromDirectory(root, entry.name, disabled, maxDescriptionChars))
+        .filter((entry) => Boolean(entry));
+}
+function loadSkillFromDirectory(root, directoryName, disabled, maxDescriptionChars) {
+    const directory = join(root.path, directoryName);
+    const filePath = join(directory, 'SKILL.md');
+    if (!isFile(filePath)) {
+        return undefined;
+    }
+    const parsed = parseSkillFile(readFileSync(filePath, 'utf8'));
+    const name = normalizeSkillName(parsed.frontmatter.name || directoryName);
+    if (!name) {
+        return undefined;
+    }
+    const frontmatterEnabled = parseBoolean(parsed.frontmatter.enabled);
+    const displayName = parsed.frontmatter.title || parsed.frontmatter.displayName || parsed.frontmatter.display_name || name;
+    const description = truncateText(parsed.frontmatter.description || firstBodyParagraph(parsed.body) || 'No description provided.', maxDescriptionChars);
+    const aliases = uniqueStringList([
+        ...parseDelimitedFrontmatterList(parsed.frontmatter.alias),
+        ...parseDelimitedFrontmatterList(parsed.frontmatter.aliases),
+    ]);
+    const keywords = uniqueStringList([
+        ...parseDelimitedFrontmatterList(parsed.frontmatter.keyword),
+        ...parseDelimitedFrontmatterList(parsed.frontmatter.keywords),
+        ...parseDelimitedFrontmatterList(parsed.frontmatter.tags),
+        ...parseDelimitedFrontmatterList(parsed.frontmatter.triggers),
+    ]);
+    const whenToUse = parsed.frontmatter.whenToUse || parsed.frontmatter.when_to_use || parsed.frontmatter.when;
+    const enabled = frontmatterEnabled !== false && !disabled.has(name);
+    return {
+        name,
+        displayName,
+        description,
+        ...(aliases.length > 0 ? { aliases } : {}),
+        ...(keywords.length > 0 ? { keywords } : {}),
+        ...(whenToUse ? { whenToUse: truncateText(whenToUse, maxDescriptionChars) } : {}),
+        source: root.source,
+        directory,
+        filePath,
+        enabled,
+        estimatedTokens: estimateSkillTokens([name, displayName, description, ...aliases, ...keywords, whenToUse].filter(Boolean).join(' ')),
+    };
+}
+function parseSkillFile(content) {
+    if (!content.startsWith('---\n') && !content.startsWith('---\r\n')) {
+        return { frontmatter: {}, body: content };
+    }
+    const newline = content.startsWith('---\r\n') ? '\r\n' : '\n';
+    const endMarker = `${newline}---${newline}`;
+    const end = content.indexOf(endMarker, 3);
+    if (end < 0) {
+        return { frontmatter: {}, body: content };
+    }
+    const rawFrontmatter = content.slice(3 + newline.length - 1, end).trim();
+    const body = content.slice(end + endMarker.length);
+    return {
+        frontmatter: parseSimpleFrontmatter(rawFrontmatter),
+        body,
+    };
+}
+function parseSimpleFrontmatter(raw) {
+    const result = {};
+    for (const line of raw.split(/\r?\n/)) {
+        const match = /^([A-Za-z][A-Za-z0-9_-]*)\s*:\s*(.*)$/.exec(line.trim());
+        if (!match?.[1]) {
+            continue;
+        }
+        result[normalizeFrontmatterKey(match[1])] = stripQuotes(match[2] ?? '');
+    }
+    return result;
+}
+function normalizeFrontmatterKey(key) {
+    if (key === 'when-to-use')
+        return 'when_to_use';
+    if (key === 'display-name')
+        return 'display_name';
+    return key;
+}
+function stripQuotes(value) {
+    const trimmed = value.trim();
+    if ((trimmed.startsWith('"') && trimmed.endsWith('"')) || (trimmed.startsWith("'") && trimmed.endsWith("'"))) {
+        return trimmed.slice(1, -1);
+    }
+    return trimmed;
+}
+function parseDelimitedFrontmatterList(value) {
+    if (!value) {
+        return [];
+    }
+    const trimmed = value.trim();
+    const unwrapped = trimmed.startsWith('[') && trimmed.endsWith(']') ? trimmed.slice(1, -1) : trimmed;
+    return unwrapped
+        .split(/[,|]/)
+        .map(stripQuotes)
+        .map(item => item.trim())
+        .filter(Boolean);
+}
+function uniqueStringList(values) {
+    return Array.from(new Set(values.map(value => value.trim()).filter(Boolean)));
+}
+function firstBodyParagraph(body) {
+    return body
+        .split(/\n\s*\n/)
+        .map(paragraph => paragraph.trim())
+        .find(paragraph => paragraph.length > 0 && !paragraph.startsWith('#'));
+}
+function parseBoolean(value) {
+    if (value === undefined) {
+        return undefined;
+    }
+    if (/^(true|yes|1)$/i.test(value)) {
+        return true;
+    }
+    if (/^(false|no|0)$/i.test(value)) {
+        return false;
+    }
+    return undefined;
+}
+function compareSkills(a, b) {
+    if (a.source !== b.source) {
+        return a.source === 'project' ? -1 : 1;
+    }
+    return a.name.localeCompare(b.name);
+}
+function normalizeSkillName(value) {
+    return value.trim().toLowerCase().replace(/[^a-z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function truncateText(value, maxChars) {
+    if (value.length <= maxChars) {
+        return value;
+    }
+    return `${value.slice(0, Math.max(0, maxChars - 14)).trimEnd()} [truncated]`;
+}
+function estimateSkillTokens(value) {
+    return Math.max(1, Math.ceil(value.length / 4));
+}
+function isFile(path) {
+    try {
+        return statSync(path).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+function safeRealpath(path) {
+    try {
+        return realpathSync(path);
+    }
+    catch {
+        return undefined;
+    }
+}

package/node_modules/@remi/skills/package.json

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