orquesta-cli 0.2.104 → 0.2.105

package/dist/core/commands/index.js

@@ -2,10 +2,12 @@ import { commandRegistry } from './registry.js';
 import { clearCommand } from './clear.js';
 import { compactCommand } from './compact.js';
 import { memoryCommand } from './memory.js';
+import { recallCommand } from './recall.js';
 import { helpCommand } from './help.js';
 commandRegistry.register(clearCommand);
 commandRegistry.register(compactCommand);
 commandRegistry.register(memoryCommand);
+commandRegistry.register(recallCommand);
 commandRegistry.register(helpCommand);
 export { commandRegistry } from './registry.js';
 //# sourceMappingURL=index.js.map

package/dist/core/commands/recall.d.ts

@@ -0,0 +1,3 @@
+import { SlashCommand } from './types.js';
+export declare const recallCommand: SlashCommand;
+//# sourceMappingURL=recall.d.ts.map

package/dist/core/commands/recall.js

@@ -0,0 +1,102 @@
+import { LOCAL_HOME_DIR } from '../../constants.js';
+import * as fs from 'fs';
+import * as path from 'path';
+const MAX_ENTRIES = 40;
+const VALUE_PREVIEW = 280;
+function stringifyValue(value) {
+    if (value == null)
+        return '';
+    if (typeof value === 'string')
+        return value;
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function scanFindings(excludeSessionId) {
+    const sessionsDir = path.join(LOCAL_HOME_DIR, 'sessions');
+    let sessionIds;
+    try {
+        sessionIds = fs.readdirSync(sessionsDir);
+    }
+    catch {
+        return [];
+    }
+    const entries = [];
+    for (const sessionId of sessionIds) {
+        if (excludeSessionId && sessionId === excludeSessionId)
+            continue;
+        const fp = path.join(sessionsDir, sessionId, 'memory.json');
+        let stat;
+        let raw;
+        try {
+            stat = fs.statSync(fp);
+            raw = fs.readFileSync(fp, 'utf8');
+        }
+        catch {
+            continue;
+        }
+        let obj;
+        try {
+            obj = JSON.parse(raw);
+        }
+        catch {
+            continue;
+        }
+        for (const [key, entry] of Object.entries(obj)) {
+            const text = stringifyValue(entry?.value).trim();
+            if (!text)
+                continue;
+            entries.push({
+                sessionId,
+                mtimeMs: stat.mtimeMs,
+                key,
+                writtenAt: entry?.writtenAt,
+                source: entry?.source,
+                text,
+            });
+        }
+    }
+    entries.sort((a, b) => (b.mtimeMs - a.mtimeMs) || (b.writtenAt || '').localeCompare(a.writtenAt || ''));
+    return entries;
+}
+function formatEntry(e) {
+    const when = e.writtenAt ? new Date(e.writtenAt).toLocaleString() : '';
+    const src = e.source ? `[${e.source}] ` : '';
+    const preview = e.text.length > VALUE_PREVIEW ? e.text.slice(0, VALUE_PREVIEW) + '…' : e.text;
+    const sid = e.sessionId.slice(0, 8);
+    return `  • ${src}${preview}\n    ↳ session ${sid} · ${e.key}${when ? ` · ${when}` : ''}`;
+}
+export const recallCommand = {
+    name: '/recall',
+    description: 'Recall findings from previous sessions: /recall | /recall <query>',
+    async execute(context, rawInput) {
+        const query = rawInput.slice('/recall'.length).trim().toLowerCase();
+        const reply = (content) => {
+            const updatedMessages = [...context.messages, { role: 'assistant', content }];
+            context.setMessages(updatedMessages);
+            return { handled: true, shouldContinue: false, updatedContext: { messages: updatedMessages } };
+        };
+        const currentSessionId = context.sessionId;
+        let entries = scanFindings(currentSessionId);
+        if (entries.length === 0) {
+            return reply('No saved findings from previous sessions yet. They accumulate as the orchestrator runs.');
+        }
+        if (query) {
+            entries = entries.filter(e => e.text.toLowerCase().includes(query) || (e.source || '').toLowerCase().includes(query));
+            if (entries.length === 0) {
+                return reply(`No previous findings match "${query}".`);
+            }
+        }
+        const shown = entries.slice(0, MAX_ENTRIES);
+        const header = query
+            ? `🔎 ${shown.length}${entries.length > MAX_ENTRIES ? `/${entries.length}` : ''} finding(s) matching "${query}":`
+            : `🧠 ${shown.length} most-recent finding(s) from previous sessions:`;
+        const body = shown.map(formatEntry).join('\n');
+        const footer = entries.length > MAX_ENTRIES ? `\n\n(${entries.length - MAX_ENTRIES} more — narrow with /recall <query>)` : '';
+        return reply(`${header}\n${body}${footer}`);
+    },
+};
+//# sourceMappingURL=recall.js.map

package/dist/ui/hooks/slashCommandProcessor.js

@@ -28,6 +28,10 @@ export const SLASH_COMMANDS = [
         name: '/role',
         description: 'Orchestration: per-role models, parallel, worktree, single-agent (single on|off)',
     },
+    {
+        name: '/recall',
+        description: 'Recall findings from previous sessions: /recall | /recall <query>',
+    },
     {
         name: '/sync',
         description: 'Sync LLM configs with Orquesta dashboard',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "orquesta-cli",
-  "version": "0.2.104",
+  "version": "0.2.105",
   "description": "Orquesta CLI - AI-powered coding assistant with team collaboration",
   "type": "module",
   "main": "dist/index.js",