evolclaw 2.8.3 → 3.1.0

package/dist/eck/detect.js

@@ -0,0 +1,47 @@
+import fs from 'fs';
+import path from 'path';
+import { BASEAGENT_CAPS } from './baseagent-caps.js';
+const MAX_DEPTH = 5;
+export function resolveEckInjection(agentConfig, projectPath, kitsRulesPath) {
+    const caps = BASEAGENT_CAPS[agentConfig.baseAgent]
+        ?? { autoLoadsRules: false, supportsSystemPrompt: true };
+    if (!caps.autoLoadsRules) {
+        return { shouldInject: true, reason: 'baseagent-no-autoload' };
+    }
+    const symlinkActive = detectEckSymlink(projectPath, kitsRulesPath);
+    if (symlinkActive) {
+        return { shouldInject: false, reason: 'symlink-active' };
+    }
+    return { shouldInject: true, reason: 'symlink-not-found' };
+}
+export function detectEckSymlink(projectPath, kitsRulesPath) {
+    let dir = projectPath;
+    let depth = 0;
+    while (depth < MAX_DEPTH) {
+        const eckDir = path.join(dir, '.claude', 'rules', 'eck');
+        if (fs.existsSync(eckDir)) {
+            try {
+                const realPath = fs.realpathSync(eckDir);
+                const kitsRulesReal = fs.realpathSync(kitsRulesPath);
+                if (pathEquals(realPath, kitsRulesReal)) {
+                    return true;
+                }
+            }
+            catch {
+                // detection failure → conservatively assume not loaded
+            }
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+        depth++;
+    }
+    return false;
+}
+function pathEquals(a, b) {
+    if (process.platform === 'win32') {
+        return path.resolve(a).toLowerCase() === path.resolve(b).toLowerCase();
+    }
+    return path.resolve(a) === path.resolve(b);
+}

package/dist/eck/init.js

@@ -0,0 +1,77 @@
+import fs from 'fs';
+import path from 'path';
+import { resolvePaths, kitsDocsDir, agentDir, getPackageRoot } from '../paths.js';
+import { atomicWriteText } from '../utils/atomic-write.js';
+import { logger } from '../utils/logger.js';
+export function initEck() {
+    const p = resolvePaths();
+    const eckDir = p.eckDir;
+    fs.mkdirSync(eckDir, { recursive: true });
+    initEckRuntime(eckDir);
+    initEckPathRegistry(eckDir);
+}
+export function initAgentIndex(aid) {
+    const indexDir = path.join(agentDir(aid), 'index');
+    fs.mkdirSync(indexDir, { recursive: true });
+    const indexFile = path.join(indexDir, 'INDEX.md');
+    const guideFile = path.join(indexDir, 'GUIDE.md');
+    if (!fs.existsSync(indexFile)) {
+        const template = loadTemplate('INDEX.template.md');
+        if (template) {
+            atomicWriteText(indexFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${indexFile}`);
+        }
+    }
+    if (!fs.existsSync(guideFile)) {
+        const template = loadTemplate('GUIDE.template.md');
+        if (template) {
+            atomicWriteText(guideFile, renderTemplate(template, { AID: aid }));
+            logger.info(`[eck] Created ${guideFile}`);
+        }
+    }
+}
+function initEckRuntime(eckDir) {
+    const runtimeFile = path.join(eckDir, 'runtime.md');
+    if (fs.existsSync(runtimeFile))
+        return;
+    const template = loadTemplate('runtime.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCLAW_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(runtimeFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${runtimeFile}`);
+}
+function initEckPathRegistry(eckDir) {
+    const registryFile = path.join(eckDir, 'path-registry.md');
+    if (fs.existsSync(registryFile))
+        return;
+    const template = loadTemplate('path-registry.template.md');
+    if (!template)
+        return;
+    const vars = {
+        EVOLCLAW_HOME: resolvePaths().root,
+        PACKAGE_ROOT: getPackageRoot(),
+    };
+    atomicWriteText(registryFile, renderTemplate(template, vars));
+    logger.info(`[eck] Created ${registryFile}`);
+}
+function loadTemplate(filename) {
+    const templatePath = path.join(kitsDocsDir(), 'eck_templates', filename);
+    try {
+        return fs.readFileSync(templatePath, 'utf-8');
+    }
+    catch {
+        logger.warn(`[eck] Template not found: ${templatePath}`);
+        return null;
+    }
+}
+function renderTemplate(template, vars) {
+    let result = template;
+    for (const [key, value] of Object.entries(vars)) {
+        result = result.replaceAll(`{{${key}}}`, value);
+    }
+    return result;
+}

package/dist/eck/rules-loader.js

@@ -0,0 +1,28 @@
+import fs from 'fs';
+import path from 'path';
+import { kitsRulesDir } from '../paths.js';
+let _cachedRules = null;
+export function loadRulesForInjection() {
+    if (_cachedRules !== null)
+        return _cachedRules;
+    const rulesDir = kitsRulesDir();
+    if (!fs.existsSync(rulesDir)) {
+        _cachedRules = '';
+        return '';
+    }
+    const files = fs.readdirSync(rulesDir)
+        .filter(f => f.endsWith('.md'))
+        .sort();
+    const parts = [];
+    for (const file of files) {
+        try {
+            parts.push(fs.readFileSync(path.join(rulesDir, file), 'utf-8'));
+        }
+        catch { /* skip unreadable files */ }
+    }
+    _cachedRules = parts.join('\n\n');
+    return _cachedRules;
+}
+export function invalidateRulesCache() {
+    _cachedRules = null;
+}