natureco-cli 5.7.13 → 5.7.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "natureco-cli",
-  "version": "5.7.13",
+  "version": "5.7.14",
   "description": "OpenClaw'dan daha güvenli, daha hızlı, daha ucuz AI agent CLI. Multi-agent, self-evolving skills, audit log, maliyet optimizasyonu ve NatureCo platform-native.",
   "bin": {
     "natureco": "bin/natureco.js"

package/src/commands/repl.js

@@ -25,6 +25,8 @@ const tui = require('../utils/tui');
 const { loadToolDefinitions, toOpenAIFormat, executeTool } = require('../utils/tools');
 const { accumulateToolCallDeltas, finalizeToolCalls } = require('../utils/streaming-tools');
 const { createPasteSafeInput, createOutputFilter, enableBracketedPaste, disableBracketedPaste, restoreNewlines, clearPasteContext } = require('../utils/paste-safe-input');
+const { getMemoryStore } = require('../utils/memory-store');
+const { buildSkillIndex } = require('../utils/skill-index');
 
 // v5.4.6: Model adi sizintisini engelle — global'e ata, callback'lerden erisebilir olsun
 const MODEL_NAMES_TO_HIDE = ['MiniMax-M2.5', 'MiniMaxM2.5', 'minimaxm25', 'Claude-3', 'GPT-4', 'ChatGPT'];
@@ -502,6 +504,12 @@ async function startRepl(args) {
   const { buildSoulContext, summarizeSoul } = require("../tools/soul");
   const soulSummary = buildSoulContext();  // 3 dosya birlesik ozet
 
+  // v5.7.14: Hermes-style memory store (MEMORY.md / USER.md) + skill index
+  const memoryStore = getMemoryStore();
+  memoryStore.load();
+  const memorySnapshotBlock = memoryStore.getSystemPromptBlock();
+  const skillsIndexBlock = buildSkillIndex();
+
   // Resume?
   let messages = [];
   if (resumeId) {
@@ -573,6 +581,12 @@ async function startRepl(args) {
     // v5.4.11: Cross-session context (Sasuke Brain)
     crossSessionContext ? `GECMISTE KONUSULAN KONULAR: Bu konulari biliyorsun, tekrar sorma:\n${crossSessionContext}` : '',
 
+    // === v5.7.14: Hermes-style memory store (MEMORY.md / USER.md) ===
+    memorySnapshotBlock,
+
+    // === v5.7.14: Skill index (progressive disclosure) ===
+    skillsIndexBlock,
+
 
   ].filter(Boolean).join(' ');
 

package/src/tools/memory.js

@@ -0,0 +1,60 @@
+/**
+ * memory — Unified memory tool (Hermes-style)
+ *
+ * Single tool with action=add|remove|replace|list, target=memory|user
+ *
+ * Coexists with existing memory_write / memory_search tools.
+ * New system prompt uses memory-store snapshot; this tool mutates live state.
+ */
+
+const { getMemoryStore } = require('../utils/memory-store');
+
+const name = 'memory';
+const description = 'Persistent memory across sessions. Use action=add to save facts, action=list to see everything, action=remove to delete by substring match. target=memory for environment facts, target=user for user preferences and traits.';
+const parameters = {
+  type: 'object',
+  properties: {
+    action: {
+      type: 'string',
+      enum: ['add', 'remove', 'replace', 'list'],
+      description: 'Operation: add (append entry), remove (by substring match), replace (find by substring, replace), list (show all)',
+    },
+    target: {
+      type: 'string',
+      enum: ['memory', 'user'],
+      description: 'Which store: memory (agent notes) or user (user preferences/habits)',
+    },
+    content: {
+      type: 'string',
+      description: 'Content to add/remove/replace. For replace, this is the new content.',
+    },
+    oldContent: {
+      type: 'string',
+      description: 'For replace: substring to match existing entry.',
+    },
+  },
+  required: ['action', 'target'],
+};
+
+async function execute(args) {
+  const store = getMemoryStore();
+  const { action, target = 'memory', content, oldContent } = args;
+
+  switch (action) {
+    case 'add':
+      if (!content) return JSON.stringify({ success: false, error: 'content required for add' });
+      return store.add(target, content);
+    case 'remove':
+      if (!content) return JSON.stringify({ success: false, error: 'content required for remove' });
+      return store.remove(target, content);
+    case 'replace':
+      if (!content || !oldContent) return JSON.stringify({ success: false, error: 'content and oldContent required for replace' });
+      return store.replace(target, oldContent, content);
+    case 'list':
+      return store.list(target);
+    default:
+      return JSON.stringify({ success: false, error: `Unknown action: ${action}` });
+  }
+}
+
+module.exports = { name, description, parameters, execute };

package/src/tools/skill_view.js

@@ -0,0 +1,37 @@
+/**
+ * skill_view — Load full skill content (progressive disclosure tier 2-3)
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { skillView, skillLookup } = require('../utils/skill-index');
+
+const name = 'skill_view';
+const description = 'Load full skill content by name. Use skills_list to discover available skills. First call returns SKILL.md body plus linked_files. Call again with filePath to access references/templates/scripts.';
+const parameters = {
+  type: 'object',
+  properties: {
+    name: { type: 'string', description: 'The skill name (use skills_list to see available skills)' },
+    filePath: { type: 'string', description: 'Optional: path to a linked file within the skill (e.g. references/api.md)' },
+  },
+  required: ['name'],
+};
+
+async function execute(args) {
+  const skill = skillLookup(args.name);
+  if (!skill) {
+    return JSON.stringify({ success: false, error: `Skill not found: ${args.name}` });
+  }
+  if (args.filePath) {
+    const skillDir = path.dirname(skill.path);
+    const filePath = path.join(skillDir, args.filePath);
+    if (!fs.existsSync(filePath)) {
+      return JSON.stringify({ success: false, error: `File not found: ${args.filePath}` });
+    }
+    const content = fs.readFileSync(filePath, 'utf8');
+    return JSON.stringify({ success: true, name: skill.name, filePath: args.filePath, content });
+  }
+  return skillView(args.name);
+}
+
+module.exports = { name, description, parameters, execute };

package/src/tools/skills_list.js

@@ -0,0 +1,21 @@
+/**
+ * skills_list — Discover available skills (progressive disclosure tier 1)
+ */
+
+const { skillsList } = require('../utils/skill-index');
+
+const name = 'skills_list';
+const description = 'List available skills with name and description. Use skill_view(name) to load full content.';
+const parameters = {
+  type: 'object',
+  properties: {
+    category: { type: 'string', description: 'Optional category filter' },
+  },
+  required: [],
+};
+
+async function execute(args) {
+  return skillsList(args.category || null);
+}
+
+module.exports = { name, description, parameters, execute };

package/src/utils/memory-store.js

@@ -1,185 +1,154 @@
 /**
- * memory_write - Memory'ye fact/kayit yaz (v5.1.1)
+ * memory-store — Hermes-style flat-file memory (MEMORY.md / USER.md)
  *
- * REPL'in extractMemoryFromMessage ozelligini tool olarak expose eder.
- * Parton'un vizyonu: "Benim asistanim, her seyimi hatirlayacak"
+ * Two stores:
+ *   - MEMORY.md: agent's notes (environment facts, project conventions, tool quirks)
+ *   - USER.md: what the agent knows about the user (preferences, habits, workflow)
+ *
+ * Entry delimiter: § (section sign). Multiline entries allowed.
+ *
+ * Frozen snapshot pattern:
+ *   - System prompt gets a snapshot captured at session start (never changes mid-session)
+ *   - Tool responses reflect live state (mutations write to disk immediately)
+ *   - Prefix cache stays stable for the entire session
+ *   - Snapshot refreshes on next session start
  */
 
-const fs = require("fs");
-const path = require("path");
-const os = require("os");
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
 
-const MEMORY_DIR = path.join(os.homedir(), ".natureco", "memory");
+const MEMORY_DIR = path.join(os.homedir(), '.natureco', 'memories');
+const ENTRY_DELIMITER = '\n§\n';
 
-function getMemoryFile(username) {
-  const name = (username || "default").toLowerCase();
-  return path.join(MEMORY_DIR, `${name}.json`);
-}
+class MemoryStore {
+  constructor(charLimit = 3000) {
+    this._memoryEntries = [];
+    this._userEntries = [];
+    this._charLimit = charLimit;
+    this._snapshot = { memory: '', user: '' };
+  }
 
-function loadMemory(username) {
-  const file = getMemoryFile(username);
-  try {
-    if (!fs.existsSync(file)) {
-      return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
+  _ensureDir() {
+    if (!fs.existsSync(MEMORY_DIR)) {
+      fs.mkdirSync(MEMORY_DIR, { recursive: true });
     }
-    return JSON.parse(fs.readFileSync(file, "utf8"));
-  } catch {
-    return { name: username || "User", nickname: null, botName: null, facts: [], preferences: [] };
   }
-}
 
-function saveMemory(username, memory) {
-  if (!fs.existsSync(MEMORY_DIR)) fs.mkdirSync(MEMORY_DIR, { recursive: true });
-  memory.lastUpdated = new Date().toISOString();
-  fs.writeFileSync(getMemoryFile(username), JSON.stringify(memory, null, 2), "utf8");
-  return memory;
-}
+  _pathFor(target) {
+    return target === 'user'
+      ? path.join(MEMORY_DIR, 'USER.md')
+      : path.join(MEMORY_DIR, 'MEMORY.md');
+  }
 
-/**
- * Score azalt (eski fact'ler zamanla unutuluyor)
- */
-function decayFacts(memory) {
-  if (!memory.facts) return memory;
-  const now = Date.now();
-  memory.facts = memory.facts.map(f => {
-    if (!f.score) f.score = 5;
-    // 1 haftadan eski -1, 1 aydan eski -3
-    const ageMs = now - new Date(f.updatedAt || f.createdAt || now).getTime();
-    const ageDays = ageMs / (1000 * 60 * 60 * 24);
-    if (ageDays > 30) f.score = Math.max(0, f.score - 3);
-    else if (ageDays > 7) f.score = Math.max(0, f.score - 1);
-    return f;
-  });
-  // score 0 olanlari sil
-  memory.facts = memory.facts.filter(f => (f.score || 0) > 0);
-  // max 15 fact tut
-  memory.facts.sort((a, b) => (b.score || 0) - (a.score || 0));
-  memory.facts = memory.facts.slice(0, 15);
-  return memory;
-}
+  _readEntries(filePath) {
+    if (!fs.existsSync(filePath)) return [];
+    const content = fs.readFileSync(filePath, 'utf8').trim();
+    if (!content) return [];
+    return content.split(ENTRY_DELIMITER).map(e => e.trim()).filter(Boolean);
+  }
 
+  _writeEntries(filePath, entries) {
+    this._ensureDir();
+    const content = entries.join(ENTRY_DELIMITER);
+    fs.writeFileSync(filePath, content + '\n', 'utf8');
+  }
 
-/**
- * v5.4.9: Memory yazma sonrasi verification — geri oku ve gercekten yazildigini dogrula
- * Self-validation mekanizmasi: tool cagirip "success" demesine ragmen dosya bos olabilir
- */
-function verifyMemoryWrite(username, expectedFact, expectedBotName) {
-  try {
-    const memFile = getMemoryFile(username);
-    if (!fs.existsSync(memFile)) {
-      return { success: false, error: "Memory dosyasi olusturulamadi: " + memFile };
-    }
-    const mem = JSON.parse(fs.readFileSync(memFile, "utf8"));
-
-    // Fact verification
-    if (expectedFact) {
-      const found = (mem.facts || []).some(f => f.value === expectedFact);
-      if (!found) {
-        return { success: false, error: "Fact memory'de bulunamadi: " + expectedFact };
-      }
-    }
+  _renderBlock(label, entries) {
+    if (!entries || entries.length === 0) return '';
+    return `=== ${label} ===\n${entries.join('\n')}\n=== ${label} sonu ===`;
+  }
 
-    // BotName verification
-    if (expectedBotName && mem.botName !== expectedBotName) {
-      return { success: false, error: "BotName guncellenmedi: " + mem.botName };
-    }
+  load() {
+    this._ensureDir();
+    this._memoryEntries = this._readEntries(this._pathFor('memory'));
+    this._userEntries = this._readEntries(this._pathFor('user'));
+    this._memoryEntries = [...new Map(this._memoryEntries.map(e => [e, e])).values()];
+    this._userEntries = [...new Map(this._userEntries.map(e => [e, e])).values()];
+    this._snapshot = {
+      memory: this._renderBlock('memory', this._memoryEntries),
+      user: this._renderBlock('user', this._userEntries),
+    };
+  }
 
-    return { success: true, message: "Memory dogrulandi" };
-  } catch (e) {
-    return { success: false, error: e.message };
+  getSnapshot() {
+    return this._snapshot;
   }
-}
 
+  getSystemPromptBlock() {
+    const parts = [];
+    if (this._snapshot.memory) parts.push(this._snapshot.memory);
+    if (this._snapshot.user) parts.push(this._snapshot.user);
+    return parts.join('\n\n');
+  }
 
-function addMemory({ username, fact, score = 5, category = "general", botName, nickname, name }) {
-  // Username yoksa ve 'name' parametresi varsa, onu username olarak kullan
-  // (Parton'un "patron" diye hitap etmesi durumu icin)
-  const effectiveUsername = username || (name && name.toLowerCase()) || 'default';
-  if (!effectiveUsername || effectiveUsername === 'default') {
-    // Hicbir username yok, default.json'a yaz
+  list(target) {
+    const entries = target === 'user' ? this._userEntries : this._memoryEntries;
+    return JSON.stringify({ success: true, entries, count: entries.length });
   }
 
-  let memory = loadMemory(effectiveUsername);
-  memory = decayFacts(memory);
-
-  // identity updates (botName, nickname, name) — name sadece memory.name, username degil
-  if (botName) memory.botName = botName;
-  if (nickname !== undefined) memory.nickname = nickname;
-  if (name) memory.name = name; // Bu memory.name (kullanici gercek adi), username degil
-
-  if (fact) {
-    // duplicate kontrol
-    const existing = memory.facts.find(f => (f.value || f).toLowerCase() === fact.toLowerCase());
-    if (existing) {
-      existing.score = Math.min(10, (existing.score || 5) + 2);
-      existing.updatedAt = new Date().toISOString();
-    } else {
-      memory.facts.push({
-        value: fact,
-        score,
-        category,
-        updatedAt: new Date().toISOString(),
-        createdAt: new Date().toISOString(),
-      });
+  add(target, content) {
+    if (!content || !content.trim()) {
+      return JSON.stringify({ success: false, error: 'Content cannot be empty.' });
     }
+    content = content.trim();
+    const entries = target === 'user' ? this._userEntries : this._memoryEntries;
+    if (entries.includes(content)) {
+      return JSON.stringify({ success: false, error: 'Duplicate entry.' });
+    }
+    const currentTotal = entries.reduce((sum, e) => sum + e.length + 3, 0);
+    if (currentTotal + content.length > this._charLimit) {
+      return JSON.stringify({ success: false, error: `Memory ${target} is full (limit ~${this._charLimit} chars). Remove some entries first.` });
+    }
+    entries.push(content);
+    this._writeEntries(this._pathFor(target), entries);
+    return JSON.stringify({ success: true, message: 'Memory entry added.', count: entries.length });
   }
 
-  if (!memory.preferences) memory.preferences = [];
-  memory = saveMemory(effectiveUsername, memory);
-
-  // v5.4.9: Verification - geri oku ve dogrula
-  const verifyResult = verifyMemoryWrite(effectiveUsername, fact, botName);
-  if (!verifyResult.success) {
-    return {
-      success: false,
-      error: "Memory yazildi ama dogrulanamadi: " + verifyResult.error,
-      username: effectiveUsername,
-    };
+  remove(target, content) {
+    if (!content || !content.trim()) {
+      return JSON.stringify({ success: false, error: 'Content cannot be empty.' });
+    }
+    content = content.trim();
+    const entries = target === 'user' ? this._userEntries : this._memoryEntries;
+    const idx = entries.findIndex(e => e.includes(content));
+    if (idx === -1) {
+      return JSON.stringify({ success: false, error: 'No matching entry found.' });
+    }
+    const removed = entries.splice(idx, 1);
+    this._writeEntries(this._pathFor(target), entries);
+    return JSON.stringify({ success: true, message: 'Memory entry removed.', removed: removed[0] });
   }
 
-  return {
-    success: true,
-    message: "Memory guncellendi ve dogrulandi",
-    username: effectiveUsername,
-    verified: true,
-    totalFacts: memory.facts.length,
-    facts: memory.facts.map(f => ({ value: f.value, score: f.score, category: f.category })),
-    botName: memory.botName,
-    nickname: memory.nickname,
-    name: memory.name,
-  };
+  replace(target, oldContent, newContent) {
+    if (!oldContent || !newContent) {
+      return JSON.stringify({ success: false, error: 'Both old and new content required.' });
+    }
+    oldContent = oldContent.trim();
+    newContent = newContent.trim();
+    const entries = target === 'user' ? this._userEntries : this._memoryEntries;
+    const idx = entries.findIndex(e => e.includes(oldContent));
+    if (idx === -1) {
+      return JSON.stringify({ success: false, error: 'No matching entry found.' });
+    }
+    entries[idx] = newContent;
+    this._writeEntries(this._pathFor(target), entries);
+    return JSON.stringify({ success: true, message: 'Memory entry updated.' });
+  }
 }
 
-function clearMemory({ username }) {
-  if (!username) return { success: false, error: "username gerekli" };
-  const file = getMemoryFile(username);
-  if (fs.existsSync(file)) fs.unlinkSync(file);
-  return { success: true, message: `Memory temizlendi: ${username}` };
-}
+let _defaultStore = null;
 
-function showMemory({ username }) {
-  if (!username) return { success: false, error: "username gerekli" };
-  const memory = loadMemory(username);
-  return {
-    success: true,
-    username,
-    name: memory.name,
-    nickname: memory.nickname,
-    botName: memory.botName,
-    totalFacts: (memory.facts || []).length,
-    facts: memory.facts || [],
-    preferences: memory.preferences || [],
-  };
+function getMemoryStore() {
+  if (!_defaultStore) {
+    _defaultStore = new MemoryStore();
+    _defaultStore.load();
+  }
+  return _defaultStore;
 }
 
+function resetMemoryStore() {
+  _defaultStore = null;
+}
 
-module.exports = {
-  getMemoryFile,
-  loadMemory,
-  saveMemory,
-  decayFacts,
-  verifyMemoryWrite,
-  addMemory,
-  clearMemory,
-  showMemory,
-};
+module.exports = { MemoryStore, getMemoryStore, resetMemoryStore, ENTRY_DELIMITER };

package/src/utils/registry.js

@@ -0,0 +1,93 @@
+/**
+ * registry — Hermes-style tool registry
+ *
+ * Each tool registers itself with:
+ *   - name: unique tool name
+ *   - toolset: group name (e.g. "file", "web", "terminal", "skills", "memory")
+ *   - schema: OpenAI function-calling schema
+ *   - handler: async function(args) => string (JSON)
+ *   - checkFn: optional function() => bool (is tool available?)
+ *   - requiresEnv: optional [envVarNames]
+ *   - emoji: optional display emoji
+ */
+
+class ToolRegistry {
+  constructor() {
+    this._tools = new Map();
+  }
+
+  register({ name, toolset, schema, handler, checkFn, requiresEnv, emoji }) {
+    if (this._tools.has(name)) {
+      return;
+    }
+    this._tools.set(name, { name, toolset, schema, handler, checkFn: checkFn || null, requiresEnv: requiresEnv || [], emoji: emoji || '' });
+  }
+
+  get(name) {
+    return this._tools.get(name) || null;
+  }
+
+  getAll() {
+    return Array.from(this._tools.values());
+  }
+
+  getByToolset(toolset) {
+    return this.getAll().filter(t => t.toolset === toolset);
+  }
+
+  getToolsets() {
+    const sets = new Set();
+    for (const t of this._tools.values()) {
+      sets.add(t.toolset);
+    }
+    return Array.from(sets).sort();
+  }
+
+  getDefinitions({ filterUnavailable } = {}) {
+    const result = [];
+    for (const entry of this._tools.values()) {
+      if (filterUnavailable && entry.checkFn) {
+        try {
+          if (!entry.checkFn()) continue;
+        } catch {
+          continue;
+        }
+      }
+      result.push({
+        type: 'function',
+        function: {
+          name: entry.name,
+          description: entry.schema.description || entry.schema.name || '',
+          parameters: entry.schema.parameters || { type: 'object', properties: {} },
+        },
+      });
+    }
+    return result;
+  }
+
+  async dispatch(name, args) {
+    const entry = this._tools.get(name);
+    if (!entry) {
+      return JSON.stringify({ error: `Unknown tool: ${name}` });
+    }
+    try {
+      return await entry.handler(args);
+    } catch (e) {
+      return JSON.stringify({ error: `${e.message || e}` });
+    }
+  }
+
+  getSchema(name) {
+    const entry = this._tools.get(name);
+    return entry ? entry.schema : null;
+  }
+
+  getEmoji(name, fallback = '') {
+    const entry = this._tools.get(name);
+    return entry ? (entry.emoji || fallback) : fallback;
+  }
+}
+
+const globalRegistry = new ToolRegistry();
+
+module.exports = { ToolRegistry, globalRegistry };

package/src/utils/skill-index.js

@@ -0,0 +1,127 @@
+/**
+ * skill-index — Hermes-style skill index builder (progressive disclosure)
+ *
+ * Scans skills/ and ~/.natureco/skills/ for SKILL.md files with YAML frontmatter.
+ * Builds a compact index for system prompt injection.
+ * Skills are loaded on-demand via skill_view(name) tool.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+const BUILTIN_SKILLS_DIR = path.join(__dirname, '..', '..', 'skills');
+const USER_SKILLS_DIR = path.join(os.homedir(), '.natureco', 'skills');
+const PROJECT_SKILLS_DIR = path.join(process.cwd(), '.natureco', 'skills');
+
+function _parseFrontmatter(content) {
+  const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!match) return { frontmatter: {}, body: content };
+  const raw = match[1];
+  const body = content.slice(match[0].length).trim();
+  const fm = {};
+  for (const line of raw.split('\n')) {
+    const sep = line.indexOf(':');
+    if (sep === -1) continue;
+    const key = line.slice(0, sep).trim();
+    const val = line.slice(sep + 1).trim();
+    fm[key] = val;
+  }
+  return { frontmatter: fm, body };
+}
+
+function _getSkillDirs() {
+  const dirs = [];
+  for (const d of [BUILTIN_SKILLS_DIR, USER_SKILLS_DIR, PROJECT_SKILLS_DIR]) {
+    if (fs.existsSync(d)) dirs.push(d);
+  }
+  return dirs;
+}
+
+function _discoverSkills() {
+  const skills = [];
+  for (const skillsDir of _getSkillDirs()) {
+    const entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const skillPath = path.join(skillsDir, entry.name, 'SKILL.md');
+      if (!fs.existsSync(skillPath)) continue;
+      const raw = fs.readFileSync(skillPath, 'utf8');
+      const { frontmatter, body } = _parseFrontmatter(raw);
+      const name = frontmatter.name || entry.name;
+      const description = frontmatter.description || '';
+      const category = path.basename(skillsDir) === 'skills' ? 'general' : path.basename(skillsDir);
+      const tags = frontmatter.metadata ? (() => { try { const m = JSON.parse(frontmatter.metadata); return m.natureco?.tags || m.hermes?.tags || []; } catch { return []; } })() : [];
+      skills.push({ name, description, fullName: entry.name, path: skillPath, category, tags, raw, body, frontmatter });
+    }
+  }
+  return skills;
+}
+
+function buildSkillIndex() {
+  const skills = _discoverSkills();
+  if (skills.length === 0) return '';
+  const byCategory = {};
+  for (const s of skills) {
+    if (!byCategory[s.category]) byCategory[s.category] = [];
+    byCategory[s.category].push(s);
+  }
+  const lines = ['## Skills'];
+  lines.push('Before replying, scan the skills below. If a skill matches your task, load it with skill_view(name) and follow its instructions.');
+  lines.push('<available_skills>');
+  for (const [cat, catSkills] of Object.entries(byCategory)) {
+    lines.push(`  ${cat}:`);
+    for (const s of catSkills) {
+      lines.push(`    - ${s.name}: ${s.description}`);
+    }
+  }
+  lines.push('</available_skills>');
+  lines.push('Only proceed without loading a skill if genuinely none are relevant.');
+  return lines.join('\n');
+}
+
+function skillLookup(name) {
+  const skills = _discoverSkills();
+  const exact = skills.find(s => s.name === name || s.fullName === name);
+  if (exact) return exact;
+  return skills.find(s => s.name.toLowerCase() === name.toLowerCase() || s.fullName.toLowerCase() === name.toLowerCase()) || null;
+}
+
+function skillView(name) {
+  const skill = skillLookup(name);
+  if (!skill) {
+    return JSON.stringify({ success: false, error: `Skill not found: ${name}` });
+  }
+  const linkedFiles = [];
+  const skillDir = path.dirname(skill.path);
+  if (fs.existsSync(skillDir)) {
+    for (const sub of ['references', 'templates', 'scripts', 'assets']) {
+      const subDir = path.join(skillDir, sub);
+      if (fs.existsSync(subDir)) {
+        for (const f of fs.readdirSync(subDir)) {
+          linkedFiles.push(`${sub}/${f}`);
+        }
+      }
+    }
+  }
+  return JSON.stringify({
+    success: true,
+    name: skill.name,
+    description: skill.description,
+    category: skill.category,
+    tags: skill.tags,
+    content: skill.body,
+    linkedFiles: linkedFiles.length > 0 ? linkedFiles : undefined,
+  });
+}
+
+function skillsList(category) {
+  const skills = _discoverSkills();
+  const filtered = category ? skills.filter(s => s.category === category) : skills;
+  return JSON.stringify({
+    success: true,
+    skills: filtered.map(s => ({ name: s.name, description: s.description, category: s.category, tags: s.tags })),
+  });
+}
+
+module.exports = { buildSkillIndex, skillLookup, skillView, skillsList };