modular-studio 1.0.3 → 1.0.5

package/dist-server/server/routes/knowledge.js

@@ -531,4 +531,3 @@ router.post('/embed', async (req, res) => {
     }
 });
 export default router;
-//# sourceMappingURL=knowledge.js.map

package/dist-server/server/routes/llm.js

@@ -197,4 +197,3 @@ router.post('/chat-tools', async (req, res) => {
     }
 });
 export default router;
-//# sourceMappingURL=llm.js.map

package/dist-server/server/routes/mcp-oauth.js

@@ -134,4 +134,3 @@ function callbackPage(success, error, serverUrl) {
 </body>
 </html>`;
 }
-//# sourceMappingURL=mcp-oauth.js.map

package/dist-server/server/routes/mcp.js

@@ -174,4 +174,3 @@ router.get('/:id/health', (req, res) => {
     }
 });
 export default router;
-//# sourceMappingURL=mcp.js.map

package/dist-server/server/routes/memory.d.ts

@@ -0,0 +1,3 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;
+//# sourceMappingURL=memory.d.ts.map

package/dist-server/server/routes/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../server/routes/memory.ts"],"names":[],"mappings":"AASA,QAAA,MAAM,MAAM,4CAAW,CAAC;AAmSxB,eAAe,MAAM,CAAC"}

package/dist-server/server/routes/memory.js

@@ -0,0 +1,283 @@
+import { Router } from 'express';
+import { SqliteAdapter } from '../services/adapters/sqliteAdapter.js';
+import { PostgresAdapter } from '../services/adapters/postgresAdapter.js';
+import { extractFacts, extractFactsWithLlm } from '../services/factExtractor.js';
+import { rankFacts } from '../services/memoryScorer.js';
+import { readConfig, writeConfig } from '../config.js';
+const router = Router();
+// Global state for the current adapter
+let currentAdapter = null;
+let currentBackend = 'local_sqlite';
+let connectionString = null;
+async function getAdapter() {
+    if (!currentAdapter) {
+        const config = readConfig();
+        const memoryConfig = config.memory || { backend: 'local_sqlite' };
+        currentBackend = memoryConfig.backend || 'local_sqlite';
+        connectionString = memoryConfig.connectionString || null;
+        if (currentBackend === 'postgres' && connectionString) {
+            currentAdapter = new PostgresAdapter(connectionString);
+        }
+        else {
+            currentAdapter = new SqliteAdapter();
+        }
+        await currentAdapter.initialize();
+    }
+    return currentAdapter;
+}
+async function switchAdapter(backend, connStr) {
+    if (currentAdapter) {
+        await currentAdapter.close();
+        currentAdapter = null;
+    }
+    currentBackend = backend;
+    connectionString = connStr || null;
+    if (backend === 'postgres' && connStr) {
+        currentAdapter = new PostgresAdapter(connStr);
+    }
+    else {
+        currentAdapter = new SqliteAdapter();
+    }
+    await currentAdapter.initialize();
+    // Save config
+    const config = readConfig();
+    config.memory = {
+        ...config.memory,
+        backend,
+        ...(connStr && { connectionString: connStr })
+    };
+    writeConfig(config);
+}
+// GET /api/memory/facts - list facts (with pagination, domain filter)
+router.get('/facts', async (req, res) => {
+    try {
+        const { domain, limit, offset } = req.query;
+        const adapter = await getAdapter();
+        const options = {};
+        if (domain)
+            options.domain = domain;
+        if (limit)
+            options.limit = parseInt(limit);
+        if (offset)
+            options.offset = parseInt(offset);
+        const facts = await adapter.getFacts(options);
+        res.json({ status: 'success', facts });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to get facts:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// POST /api/memory/facts - create fact
+router.post('/facts', async (req, res) => {
+    try {
+        const fact = req.body;
+        if (!fact.id || !fact.content) {
+            return res.status(400).json({
+                status: 'error',
+                error: 'Missing required fields: id, content'
+            });
+        }
+        const adapter = await getAdapter();
+        await adapter.storeFact(fact);
+        res.json({ status: 'success' });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to create fact:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// PUT /api/memory/facts/:id - update fact
+router.put('/facts/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const patch = req.body;
+        const adapter = await getAdapter();
+        await adapter.updateFact(id, patch);
+        res.json({ status: 'success' });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to update fact:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// DELETE /api/memory/facts/:id - delete fact
+router.delete('/facts/:id', async (req, res) => {
+    try {
+        const { id } = req.params;
+        const adapter = await getAdapter();
+        await adapter.deleteFact(id);
+        res.json({ status: 'success' });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to delete fact:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// POST /api/memory/search - semantic search
+router.post('/search', async (req, res) => {
+    try {
+        const { query, k } = req.body;
+        if (!query) {
+            return res.status(400).json({
+                status: 'error',
+                error: 'Missing required field: query'
+            });
+        }
+        const adapter = await getAdapter();
+        const results = await adapter.searchFacts(query, k || 5);
+        res.json({ status: 'success', results });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to search facts:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// POST /api/memory/extract - call factExtractor on input text
+router.post('/extract', async (req, res) => {
+    try {
+        const { text, agentId, useLlm, providerId, model } = req.body;
+        if (!text || !agentId) {
+            return res.status(400).json({
+                status: 'error',
+                error: 'Missing required fields: text, agentId'
+            });
+        }
+        let facts;
+        if (useLlm && providerId && model) {
+            facts = await extractFactsWithLlm(text, agentId, providerId, model);
+        }
+        else {
+            facts = extractFacts(text, agentId);
+        }
+        res.json({ status: 'success', facts });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to extract facts:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// POST /api/memory/score - call memoryScorer on facts
+router.post('/score', async (req, res) => {
+    try {
+        const { facts, query, limit } = req.body;
+        if (!facts || !Array.isArray(facts)) {
+            return res.status(400).json({
+                status: 'error',
+                error: 'Missing or invalid required field: facts (array)'
+            });
+        }
+        const scored = rankFacts(facts, query || '', limit);
+        res.json({ status: 'success', facts: scored });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to score facts:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// GET /api/memory/config - get current backend config
+router.get('/config', (_req, res) => {
+    try {
+        const config = readConfig();
+        const memoryConfig = config.memory || { backend: 'local_sqlite' };
+        res.json({
+            status: 'success',
+            config: {
+                ...memoryConfig,
+                backend: currentBackend,
+                connectionString: currentBackend === 'postgres' ? connectionString : undefined
+            }
+        });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to get config:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// POST /api/memory/config - set backend config (store type, connection string)
+router.post('/config', async (req, res) => {
+    try {
+        const { backend, connectionString: connStr } = req.body;
+        if (!backend) {
+            return res.status(400).json({
+                status: 'error',
+                error: 'Missing required field: backend'
+            });
+        }
+        if (backend === 'postgres' && !connStr) {
+            return res.status(400).json({
+                status: 'error',
+                error: 'PostgreSQL backend requires connectionString'
+            });
+        }
+        // Test connection before switching
+        let testAdapter;
+        if (backend === 'postgres') {
+            testAdapter = new PostgresAdapter(connStr);
+        }
+        else {
+            testAdapter = new SqliteAdapter();
+        }
+        try {
+            await testAdapter.initialize();
+            await testAdapter.getHealth();
+            await testAdapter.close();
+        }
+        catch (testError) {
+            return res.status(400).json({
+                status: 'error',
+                error: `Failed to connect to ${backend}: ${testError instanceof Error ? testError.message : 'Unknown error'}`
+            });
+        }
+        await switchAdapter(backend, connStr);
+        res.json({ status: 'success' });
+    }
+    catch (error) {
+        console.error('[Memory] Failed to set config:', error);
+        res.status(500).json({
+            status: 'error',
+            error: error instanceof Error ? error.message : 'Unknown error'
+        });
+    }
+});
+// GET /api/memory/health - backend health check (never 500 — always returns a health object)
+router.get('/health', async (_req, res) => {
+    try {
+        const adapter = await getAdapter();
+        const health = await adapter.getHealth();
+        res.json({ status: 'success', health, backend: currentBackend });
+    }
+    catch (error) {
+        // Return 200 with degraded health — don't 500 or the frontend will loop
+        res.json({
+            status: 'success',
+            health: { status: 'unavailable', factCount: 0, error: error instanceof Error ? error.message : 'Adapter init failed' },
+            backend: currentBackend
+        });
+    }
+});
+export default router;

package/dist-server/server/routes/pipeline.js

@@ -480,4 +480,3 @@ router.post('/assemble', async (req, res) => {
     }
 });
 export default router;
-//# sourceMappingURL=pipeline.js.map

package/dist-server/server/routes/providers.js

@@ -201,4 +201,3 @@ router.post('/:id/test', async (req, res) => {
     }
 });
 export default router;
-//# sourceMappingURL=providers.js.map

package/dist-server/server/routes/qualification.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"qualification.d.ts","sourceRoot":"","sources":["../../../server/routes/qualification.ts"],"names":[],"mappings":"AAIA,QAAA,MAAM,MAAM,4CAAW,CAAC;AA2LxB,eAAe,MAAM,CAAC"}
+{"version":3,"file":"qualification.d.ts","sourceRoot":"","sources":["../../../server/routes/qualification.ts"],"names":[],"mappings":"AAKA,QAAA,MAAM,MAAM,4CAAW,CAAC;AAijBxB,eAAe,MAAM,CAAC"}