morpheus-cli 0.9.5 → 0.9.7

package/dist/cli/commands/start.js

@@ -26,6 +26,8 @@ import { ChronosRepository } from '../../runtime/chronos/repository.js';
 import { SkillRegistry } from '../../runtime/skills/index.js';
 import { MCPToolCache } from '../../runtime/tools/cache.js';
 import { SmithRegistry } from '../../runtime/smiths/registry.js';
+import { Link } from '../../runtime/link.js';
+import { LinkWorker } from '../../runtime/link-worker.js';
 // Load .env file explicitly in start command
 const envPath = path.join(process.cwd(), '.env');
 if (fs.existsSync(envPath)) {
@@ -173,6 +175,16 @@ export const startCommand = new Command('start')
         catch (err) {
             display.log(chalk.yellow(`Smiths initialization warning: ${err.message}`), { source: 'Smiths' });
         }
+        // Initialize Link (Documentation Specialist) before Oracle
+        try {
+            const linkConfig = ConfigManager.getInstance().getLinkConfig();
+            const link = Link.getInstance(config);
+            await link.initialize();
+            display.log(chalk.green('✓ Link initialized'), { source: 'Link' });
+        }
+        catch (err) {
+            display.log(chalk.yellow(`Link initialization warning: ${err.message}`), { source: 'Link' });
+        }
         // Initialize Oracle
         const oracle = new Oracle(config);
         try {
@@ -228,6 +240,7 @@ export const startCommand = new Command('start')
                 const telegram = new TelegramAdapter(oracle);
                 try {
                     await telegram.connect(config.channels.telegram.token, config.channels.telegram.allowedUsers || []);
+                    await telegram.restoreUserSessions();
                     ChannelRegistry.register(telegram);
                     adapters.push(telegram);
                 }
@@ -245,6 +258,7 @@ export const startCommand = new Command('start')
                 const discord = new DiscordAdapter(oracle);
                 try {
                     await discord.connect(config.channels.discord.token, config.channels.discord.allowedUsers || []);
+                    await discord.restoreUserSessions();
                     ChannelRegistry.register(discord);
                     adapters.push(discord);
                 }
@@ -259,6 +273,9 @@ export const startCommand = new Command('start')
         // Start Background Services
         startSessionEmbeddingScheduler();
         chronosWorker.start();
+        // Start LinkWorker for document indexing
+        const linkWorker = LinkWorker.getInstance();
+        linkWorker.start();
         if (asyncTasksEnabled) {
             taskWorker.start();
             taskNotifier.start();
@@ -278,6 +295,7 @@ export const startCommand = new Command('start')
                 await adapter.disconnect();
             }
             chronosWorker.stop();
+            linkWorker.stop();
             if (asyncTasksEnabled) {
                 taskWorker.stop();
                 taskNotifier.stop();

package/dist/config/manager.js

@@ -53,6 +53,10 @@ export class ConfigManager {
         if (decrypted.trinity?.api_key) {
             decrypted.trinity = { ...decrypted.trinity, api_key: tryDecrypt(decrypted.trinity.api_key) };
         }
+        // Decrypt Link
+        if (decrypted.link?.api_key) {
+            decrypted.link = { ...decrypted.link, api_key: tryDecrypt(decrypted.link.api_key) };
+        }
         // Decrypt Audio (Telephonist)
         if (decrypted.audio?.apiKey) {
             decrypted.audio = { ...decrypted.audio, apiKey: tryDecrypt(decrypted.audio.apiKey) };
@@ -95,6 +99,10 @@ export class ConfigManager {
         if (encrypted.trinity?.api_key) {
             encrypted.trinity = { ...encrypted.trinity, api_key: tryEncrypt(encrypted.trinity.api_key) };
         }
+        // Encrypt Link
+        if (encrypted.link?.api_key) {
+            encrypted.link = { ...encrypted.link, api_key: tryEncrypt(encrypted.link.api_key) };
+        }
         // Encrypt Audio (Telephonist)
         if (encrypted.audio?.apiKey) {
             encrypted.audio = { ...encrypted.audio, apiKey: tryEncrypt(encrypted.audio.apiKey) };
@@ -240,6 +248,38 @@ export class ConfigManager {
                 execution_mode: resolveString('MORPHEUS_TRINITY_EXECUTION_MODE', config.trinity?.execution_mode, 'async'),
             };
         }
+        // Apply precedence to Link config
+        const linkEnvVars = [
+            'MORPHEUS_LINK_PROVIDER',
+            'MORPHEUS_LINK_MODEL',
+            'MORPHEUS_LINK_TEMPERATURE',
+            'MORPHEUS_LINK_API_KEY',
+        ];
+        const hasLinkEnvOverrides = linkEnvVars.some((envVar) => process.env[envVar] !== undefined);
+        let linkConfig;
+        if (config.link || hasLinkEnvOverrides) {
+            const linkProvider = resolveProvider('MORPHEUS_LINK_PROVIDER', config.link?.provider, llmConfig.provider);
+            const linkMaxTokensFallback = config.link?.max_tokens ?? llmConfig.max_tokens;
+            const linkContextWindowFallback = config.link?.context_window ?? llmConfig.context_window;
+            linkConfig = {
+                provider: linkProvider,
+                model: resolveModel(linkProvider, 'MORPHEUS_LINK_MODEL', config.link?.model || llmConfig.model),
+                temperature: resolveNumeric('MORPHEUS_LINK_TEMPERATURE', config.link?.temperature, llmConfig.temperature),
+                max_tokens: resolveOptionalNumeric('MORPHEUS_LINK_MAX_TOKENS', config.link?.max_tokens, linkMaxTokensFallback),
+                api_key: resolveApiKey(linkProvider, 'MORPHEUS_LINK_API_KEY', config.link?.api_key || llmConfig.api_key),
+                base_url: config.link?.base_url || config.llm.base_url,
+                context_window: resolveOptionalNumeric('MORPHEUS_LINK_CONTEXT_WINDOW', config.link?.context_window, linkContextWindowFallback),
+                chunk_size: resolveNumeric('MORPHEUS_LINK_CHUNK_SIZE', config.link?.chunk_size, 500),
+                score_threshold: resolveNumeric('MORPHEUS_LINK_SCORE_THRESHOLD', config.link?.score_threshold, 0.5),
+                max_results: resolveNumeric('MORPHEUS_LINK_MAX_RESULTS', config.link?.max_results, 10),
+                execution_mode: resolveString('MORPHEUS_LINK_EXECUTION_MODE', config.link?.execution_mode, 'async'),
+                scan_interval_ms: resolveNumeric('MORPHEUS_LINK_SCAN_INTERVAL_MS', config.link?.scan_interval_ms, 30000),
+                max_file_size_mb: resolveNumeric('MORPHEUS_LINK_MAX_FILE_SIZE_MB', config.link?.max_file_size_mb, 50),
+                vector_weight: resolveNumeric('MORPHEUS_LINK_VECTOR_WEIGHT', config.link?.vector_weight, 0.8),
+                bm25_weight: resolveNumeric('MORPHEUS_LINK_BM25_WEIGHT', config.link?.bm25_weight, 0.2),
+                personality: resolveString('MORPHEUS_LINK_PERSONALITY', config.link?.personality, 'documentation_specialist'),
+            };
+        }
         // Apply precedence to audio config
         const audioProvider = resolveString('MORPHEUS_AUDIO_PROVIDER', config.audio.provider, DEFAULT_CONFIG.audio.provider);
         // AudioProvider uses 'google' but resolveApiKey expects LLMProvider which uses 'gemini'
@@ -312,6 +352,7 @@ export class ConfigManager {
             neo: neoConfig,
             apoc: apocConfig,
             trinity: trinityConfig,
+            link: linkConfig,
             audio: audioConfig,
             channels: channelsConfig,
             ui: uiConfig,
@@ -436,6 +477,26 @@ export class ConfigManager {
         }
         return defaults;
     }
+    getLinkConfig() {
+        const defaults = {
+            provider: this.config.llm.provider,
+            model: this.config.llm.model,
+            temperature: this.config.llm.temperature,
+            personality: 'documentation_specialist',
+            chunk_size: 500,
+            score_threshold: 0.5,
+            max_results: 10,
+            execution_mode: 'async',
+            scan_interval_ms: 30000,
+            max_file_size_mb: 50,
+            vector_weight: 0.8,
+            bm25_weight: 0.2,
+        };
+        if (this.config.link) {
+            return { ...defaults, ...this.config.link };
+        }
+        return defaults;
+    }
     getDevKitConfig() {
         const defaults = {
             sandbox_dir: process.cwd(),

package/dist/config/paths.js

@@ -15,4 +15,5 @@ export const PATHS = {
     commands: path.join(MORPHEUS_ROOT, 'commands'),
     mcps: path.join(MORPHEUS_ROOT, 'mcps.json'),
     skills: path.join(MORPHEUS_ROOT, 'skills'),
+    docs: path.join(MORPHEUS_ROOT, 'docs'),
 };

package/dist/config/schemas.js

@@ -35,8 +35,16 @@ export const NeoConfigSchema = LLMConfigSchema.extend({
 export const TrinityConfigSchema = LLMConfigSchema.extend({
     execution_mode: z.enum(['sync', 'async']).default('async'),
 });
-export const KeymakerConfigSchema = LLMConfigSchema.extend({
-    skills_dir: z.string().optional(),
+export const LinkConfigSchema = LLMConfigSchema.extend({
+    personality: z.string().optional(),
+    chunk_size: z.number().int().positive().default(500),
+    score_threshold: z.number().min(0).max(1).default(0.5),
+    max_results: z.number().int().positive().default(10),
+    execution_mode: z.enum(['sync', 'async']).default('async'),
+    scan_interval_ms: z.number().int().min(5000).default(30000),
+    max_file_size_mb: z.number().int().positive().default(50),
+    vector_weight: z.number().min(0).max(1).default(0.8),
+    bm25_weight: z.number().min(0).max(1).default(0.2),
 });
 export const WebhookConfigSchema = z.object({
     telegram_notify_all: z.boolean().optional(),
@@ -86,7 +94,7 @@ export const ConfigSchema = z.object({
     neo: NeoConfigSchema.optional(),
     apoc: ApocConfigSchema.optional(),
     trinity: TrinityConfigSchema.optional(),
-    keymaker: KeymakerConfigSchema.optional(),
+    link: LinkConfigSchema.optional(),
     webhooks: WebhookConfigSchema,
     audio: AudioConfigSchema.default(DEFAULT_CONFIG.audio),
     memory: z.object({

package/dist/http/api.js

@@ -21,6 +21,7 @@ import { createChronosJobRouter, createChronosConfigRouter } from './routers/chr
 import { createSkillsRouter } from './routers/skills.js';
 import { createSmithsRouter } from './routers/smiths.js';
 import { createDangerRouter } from './routers/danger.js';
+import { createLinkRouter } from './routers/link.js';
 import { getActiveEnvOverrides } from '../config/precedence.js';
 import { hotReloadConfig, getRestartRequiredChanges } from '../runtime/hot-reload.js';
 import { AuditRepository } from '../runtime/audit/repository.js';
@@ -52,6 +53,8 @@ export function createApiRouter(oracle, chronosWorker) {
     router.use('/smiths', createSmithsRouter());
     // Mount Danger Zone router
     router.use('/danger', createDangerRouter());
+    // Mount Link router (Documentation management)
+    router.use('/link', createLinkRouter());
     // --- Session Management ---
     router.get('/sessions', async (req, res) => {
         try {

package/dist/http/routers/link.js

@@ -0,0 +1,239 @@
+import { Router } from 'express';
+import multer from 'multer';
+import path from 'path';
+import fs from 'fs-extra';
+import { homedir } from 'os';
+import { LinkRepository } from '../../runtime/link-repository.js';
+import { LinkWorker } from '../../runtime/link-worker.js';
+import { ConfigManager } from '../../config/manager.js';
+const DOCS_PATH = path.join(homedir(), '.morpheus', 'docs');
+// Configure multer for file uploads
+const storage = multer.diskStorage({
+    destination: async (req, file, cb) => {
+        await fs.ensureDir(DOCS_PATH);
+        cb(null, DOCS_PATH);
+    },
+    filename: (req, file, cb) => {
+        // Multer decodes originalname as Latin1 per HTTP spec.
+        // Re-encode to get the raw bytes and decode as UTF-8.
+        const fixedName = Buffer.from(file.originalname, 'latin1').toString('utf-8');
+        cb(null, fixedName);
+    },
+});
+const upload = multer({
+    storage,
+    limits: {
+        fileSize: 50 * 1024 * 1024, // 50MB default, will check config
+    },
+    fileFilter: (req, file, cb) => {
+        const name = Buffer.from(file.originalname, 'latin1').toString('utf-8');
+        const ext = path.extname(name).toLowerCase();
+        const allowed = ['.pdf', '.txt', '.md', '.docx'];
+        if (allowed.includes(ext)) {
+            cb(null, true);
+        }
+        else {
+            cb(new Error(`Unsupported file type: ${ext}. Allowed: ${allowed.join(', ')}`));
+        }
+    },
+});
+/**
+ * Create the Link router for document management.
+ */
+export function createLinkRouter() {
+    const router = Router();
+    const repository = LinkRepository.getInstance();
+    const worker = LinkWorker.getInstance();
+    // GET /api/link/documents - List all documents
+    router.get('/documents', (req, res) => {
+        try {
+            const status = req.query.status;
+            const documents = repository.listDocuments(status);
+            const stats = repository.getStats();
+            res.json({
+                documents,
+                stats,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/link/documents/:id - Get single document
+    router.get('/documents/:id', (req, res) => {
+        try {
+            const document = repository.getDocument(req.params.id);
+            if (!document) {
+                return res.status(404).json({ error: 'Document not found' });
+            }
+            // Also fetch chunks
+            const chunks = repository.getChunksByDocument(req.params.id);
+            res.json({ document, chunks });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/link/documents/upload - Upload a new document
+    router.post('/documents/upload', async (req, res) => {
+        try {
+            const config = ConfigManager.getInstance().getLinkConfig();
+            const maxSizeMB = config.max_file_size_mb;
+            // Configure multer with config max size
+            const uploadWithConfig = multer({
+                storage,
+                limits: { fileSize: maxSizeMB * 1024 * 1024 },
+                fileFilter: (req, file, cb) => {
+                    const name = Buffer.from(file.originalname, 'latin1').toString('utf-8');
+                    const ext = path.extname(name).toLowerCase();
+                    const allowed = ['.pdf', '.txt', '.md', '.docx'];
+                    if (allowed.includes(ext)) {
+                        cb(null, true);
+                    }
+                    else {
+                        cb(new Error(`Unsupported file type: ${ext}`));
+                    }
+                },
+            });
+            // Handle upload
+            await new Promise((resolve, reject) => {
+                uploadWithConfig.single('file')(req, res, (err) => {
+                    if (err)
+                        reject(err);
+                    else
+                        resolve();
+                });
+            });
+            if (!req.file) {
+                return res.status(400).json({ error: 'No file uploaded' });
+            }
+            // Trigger immediate scan
+            const result = await worker.tick();
+            res.json({
+                message: 'File uploaded successfully',
+                filename: Buffer.from(req.file.originalname, 'latin1').toString('utf-8'),
+                path: req.file.path,
+                indexed: result.indexed,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // DELETE /api/link/documents/:id - Delete a document
+    router.delete('/documents/:id', async (req, res) => {
+        try {
+            const document = repository.getDocument(req.params.id);
+            if (!document) {
+                return res.status(404).json({ error: 'Document not found' });
+            }
+            // Delete from repository (CASCADE removes chunks and embeddings)
+            const deleted = repository.deleteDocument(req.params.id);
+            // Also delete file from disk
+            try {
+                await fs.unlink(document.file_path);
+            }
+            catch {
+                // File may not exist, ignore
+            }
+            res.json({ message: 'Document deleted', deleted });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/link/documents/:id/reindex - Force reindex a document
+    router.post('/documents/:id/reindex', async (req, res) => {
+        try {
+            const document = repository.getDocument(req.params.id);
+            if (!document) {
+                return res.status(404).json({ error: 'Document not found' });
+            }
+            // Check if file still exists
+            const exists = await fs.pathExists(document.file_path);
+            if (!exists) {
+                return res.status(400).json({ error: 'Document file no longer exists' });
+            }
+            // Reset status to pending and trigger processing
+            repository.updateDocumentStatus(req.params.id, 'pending');
+            // Process the document
+            const result = await worker.processDocument(document.file_path);
+            res.json({
+                message: 'Document reindexed',
+                result,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/link/config - Get Link configuration
+    router.get('/config', (req, res) => {
+        try {
+            const config = ConfigManager.getInstance().getLinkConfig();
+            res.json(config);
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/link/config - Update Link configuration (partial update)
+    router.post('/config', async (req, res) => {
+        try {
+            const configManager = ConfigManager.getInstance();
+            const currentConfig = configManager.get();
+            const currentLinkConfig = configManager.getLinkConfig();
+            const updates = req.body;
+            // Merge updates with current config (ensuring all required fields are present)
+            const newLinkConfig = {
+                ...currentLinkConfig,
+                ...updates,
+            };
+            // Save to zaion.yaml
+            await configManager.save({
+                ...currentConfig,
+                link: newLinkConfig,
+            });
+            // Update worker interval if changed
+            if (updates.scan_interval_ms) {
+                worker.updateInterval(updates.scan_interval_ms);
+            }
+            res.json({
+                message: 'Configuration updated',
+                config: configManager.getLinkConfig(),
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // POST /api/link/worker/scan - Trigger manual scan
+    router.post('/worker/scan', async (req, res) => {
+        try {
+            const result = await worker.tick();
+            res.json({
+                message: 'Scan completed',
+                ...result,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    // GET /api/link/worker/status - Get worker status
+    router.get('/worker/status', (req, res) => {
+        try {
+            const config = ConfigManager.getInstance().getLinkConfig();
+            const stats = repository.getStats();
+            res.json({
+                running: true, // Worker is always running when daemon is up
+                scan_interval_ms: config.scan_interval_ms,
+                ...stats,
+            });
+        }
+        catch (err) {
+            res.status(500).json({ error: err.message });
+        }
+    });
+    return router;
+}

package/dist/http/routers/skills.js

@@ -4,7 +4,7 @@ import extract from 'extract-zip';
 import fs from 'fs-extra';
 import path from 'path';
 import os from 'os';
-import { SkillRegistry, updateSkillDelegateDescription } from '../../runtime/skills/index.js';
+import { SkillRegistry } from '../../runtime/skills/index.js';
 import { DisplayManager } from '../../runtime/display.js';
 import { PATHS } from '../../config/paths.js';
 import { SkillMetadataSchema } from '../../runtime/skills/schema.js';
@@ -119,8 +119,6 @@ export function createSkillsRouter() {
         try {
             const registry = SkillRegistry.getInstance();
             const result = await registry.reload();
-            // Update skill_delegate tool description with new skills
-            updateSkillDelegateDescription();
             display.log(`Skills reloaded: ${result.skills.length} loaded, ${result.errors.length} errors`, {
                 source: 'SkillsAPI',
             });
@@ -207,7 +205,6 @@ export function createSkillsRouter() {
             // Reload skills
             const registry = SkillRegistry.getInstance();
             await registry.reload();
-            updateSkillDelegateDescription();
             display.log(`Skill "${metadata.name}" uploaded successfully`, { source: 'SkillsAPI' });
             res.json({
                 success: true,
@@ -258,8 +255,6 @@ export function createSkillsRouter() {
             if (!success) {
                 return res.status(404).json({ error: `Skill "${name}" not found` });
             }
-            // Update skill_delegate tool description
-            updateSkillDelegateDescription();
             display.log(`Skill "${name}" enabled`, { source: 'SkillsAPI' });
             res.json({ success: true, name, enabled: true });
         }
@@ -277,8 +272,6 @@ export function createSkillsRouter() {
             if (!success) {
                 return res.status(404).json({ error: `Skill "${name}" not found` });
             }
-            // Update skill_delegate tool description
-            updateSkillDelegateDescription();
             display.log(`Skill "${name}" disabled`, { source: 'SkillsAPI' });
             res.json({ success: true, name, enabled: false });
         }

package/dist/runtime/apoc.js

@@ -259,7 +259,7 @@ ${context ? `CONTEXT FROM ORACLE:\n${context}` : ""}
         try {
             const inputCount = messages.length;
             const startMs = Date.now();
-            const response = await this.agent.invoke({ messages }, { recursionLimit: 50 });
+            const response = await this.agent.invoke({ messages }, { recursionLimit: 10 });
             const durationMs = Date.now() - startMs;
             const apocConfig = this.config.apoc || this.config.llm;
             const lastMessage = response.messages[response.messages.length - 1];

package/dist/runtime/audit/repository.js

@@ -188,7 +188,7 @@ export class AuditRepository {
         SUM(CASE WHEN ae.event_type = 'llm_call'        THEN 1 ELSE 0 END) as llmCallCount,
         SUM(CASE WHEN ae.event_type = 'tool_call'       THEN 1 ELSE 0 END) as toolCallCount,
         SUM(CASE WHEN ae.event_type = 'mcp_tool'        THEN 1 ELSE 0 END) as mcpToolCount,
-        SUM(CASE WHEN ae.event_type = 'skill_executed'  THEN 1 ELSE 0 END) as skillCount,
+        SUM(CASE WHEN ae.event_type = 'skill_loaded'  THEN 1 ELSE 0 END) as skillCount,
         SUM(CASE WHEN ae.event_type = 'memory_recovery' THEN 1 ELSE 0 END) as memoryRecoveryCount,
         SUM(CASE WHEN ae.event_type = 'memory_persist'  THEN 1 ELSE 0 END) as memoryPersistCount,
         SUM(CASE WHEN ae.event_type = 'chronos_job'     THEN 1 ELSE 0 END) as chronosJobCount,