notoken-core 1.4.0 → 1.5.0

package/dist/index.d.ts

@@ -45,7 +45,8 @@ export { formatParsedCommand } from "./utils/output.js";
 export { Spinner, withSpinner, progressBar } from "./utils/spinner.js";
 export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupList } from "./utils/autoBackup.js";
 export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner, type UpdateInfo } from "./utils/updater.js";
-export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, type LLMProvider, type LLMState, } from "./utils/llmManager.js";
+export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, getSessionId, type LLMProvider, type LLMState, } from "./utils/llmManager.js";
+export { getRecentSessions, getSessionsForFolder, formatSessionSummary, formatSessionList, type SessionSummary, } from "./utils/sessionSummary.js";
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";
 export { recordHistory, loadHistory, getRecentHistory, searchHistory } from "./context/history.js";

package/dist/index.js

@@ -59,7 +59,9 @@ export { createBackup, rollback, listBackups, cleanExpiredBackups, formatBackupL
 // ── Updates ──
 export { checkForUpdate, checkForUpdateSync, runUpdate, formatUpdateBanner } from "./utils/updater.js";
 // ── LLM Manager ──
-export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, } from "./utils/llmManager.js";
+export { detectProviders, formatStatus, goOffline, goOnline, disableLLM, enableLLM, isOfflineMode, isLLMDisabled, recordOfflineCommand, getTokensSaved, formatTokensSaved, formatTokensSavedBrief, saveOnExit, getSessionId, } from "./utils/llmManager.js";
+// ── Session Summaries ──
+export { getRecentSessions, getSessionsForFolder, formatSessionSummary, formatSessionList, } from "./utils/sessionSummary.js";
 // ── Logging ──
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";

package/dist/utils/llmManager.d.ts

@@ -25,6 +25,15 @@ export interface LLMState {
     tokensSaved: number;
     commandsHandledOffline: number;
     lastSaved: string;
+    sessions: SessionStats[];
+}
+export interface SessionStats {
+    id: string;
+    folder: string;
+    startedAt: string;
+    endedAt?: string;
+    tokensSaved: number;
+    commandsHandled: number;
 }
 export declare function detectProviders(): LLMProvider[];
 export declare function formatStatus(): string;
@@ -36,9 +45,16 @@ export declare function isOfflineMode(): boolean;
 export declare function isLLMDisabled(name: string): boolean;
 export declare function recordOfflineCommand(): void;
 export declare function getTokensSaved(): {
-    tokens: number;
-    commands: number;
+    session: {
+        tokens: number;
+        commands: number;
+    };
+    total: {
+        tokens: number;
+        commands: number;
+    };
 };
 export declare function formatTokensSaved(): string;
 export declare function formatTokensSavedBrief(): string;
+export declare function getSessionId(): string;
 export declare function saveOnExit(): void;

package/dist/utils/llmManager.js

@@ -21,6 +21,12 @@ const c = {
     green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m", cyan: "\x1b[36m",
 };
 // ─── State Persistence ──────────────────────────────────────────────────────
+// Per-session counters (reset each launch)
+let sessionTokens = 0;
+let sessionCommands = 0;
+const sessionId = `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+const sessionStartedAt = new Date().toISOString();
+const sessionFolder = process.cwd();
 function loadState() {
     try {
         if (existsSync(STATE_FILE)) {
@@ -28,13 +34,16 @@ function loadState() {
         }
     }
     catch { }
-    return { offlineMode: false, disabled: [], tokensSaved: 0, commandsHandledOffline: 0, lastSaved: new Date().toISOString() };
+    return { offlineMode: false, disabled: [], tokensSaved: 0, commandsHandledOffline: 0, lastSaved: new Date().toISOString(), sessions: [] };
 }
-function saveState(state) {
+function saveState(s) {
     try {
         mkdirSync(USER_HOME, { recursive: true });
-        state.lastSaved = new Date().toISOString();
-        writeFileSync(STATE_FILE, JSON.stringify(state, null, 2));
+        s.lastSaved = new Date().toISOString();
+        // Keep last 50 sessions
+        if (s.sessions.length > 50)
+            s.sessions = s.sessions.slice(-50);
+        writeFileSync(STATE_FILE, JSON.stringify(s, null, 2));
     }
     catch { }
 }
@@ -111,7 +120,9 @@ export function formatStatus() {
     }
     // Token savings
     lines.push("");
-    lines.push(`  ${c.cyan}Tokens saved:${c.reset} ~${formatTokens(state.tokensSaved)} (${state.commandsHandledOffline} commands handled offline)`);
+    lines.push(`  ${c.bold}This session:${c.reset} ~${formatTokens(sessionTokens)} tokens saved (${sessionCommands} commands)`);
+    lines.push(`  ${c.bold}All time:${c.reset}     ~${formatTokens(state.tokensSaved)} tokens saved (${state.commandsHandledOffline} commands)`);
+    lines.push(`  ${c.dim}Session: ${sessionId} | Folder: ${sessionFolder}${c.reset}`);
     return lines.join("\n");
 }
 // ─── Controls ───────────────────────────────────────────────────────────────
@@ -150,27 +161,47 @@ const AVG_TOKENS_PER_CALL = 700;
 export function recordOfflineCommand() {
     state.commandsHandledOffline++;
     state.tokensSaved += AVG_TOKENS_PER_CALL;
-    // Save periodically (every 10 commands)
+    sessionCommands++;
+    sessionTokens += AVG_TOKENS_PER_CALL;
     if (state.commandsHandledOffline % 10 === 0)
         saveState(state);
 }
 export function getTokensSaved() {
-    return { tokens: state.tokensSaved, commands: state.commandsHandledOffline };
+    return {
+        session: { tokens: sessionTokens, commands: sessionCommands },
+        total: { tokens: state.tokensSaved, commands: state.commandsHandledOffline },
+    };
 }
 export function formatTokensSaved() {
-    const { tokens, commands } = getTokensSaved();
-    if (commands === 0)
+    if (sessionCommands === 0 && state.commandsHandledOffline === 0)
         return "";
-    return `${c.dim}~${formatTokens(tokens)} tokens saved (${commands} commands handled offline)${c.reset}`;
+    const lines = [];
+    if (sessionCommands > 0) {
+        lines.push(`${c.dim}This session: ~${formatTokens(sessionTokens)} tokens saved (${sessionCommands} commands)${c.reset}`);
+    }
+    lines.push(`${c.dim}All time: ~${formatTokens(state.tokensSaved)} tokens saved (${state.commandsHandledOffline} commands)${c.reset}`);
+    return lines.join("\n");
 }
 export function formatTokensSavedBrief() {
-    const { tokens, commands } = getTokensSaved();
-    if (commands === 0)
+    if (sessionCommands === 0)
         return "";
-    return `${c.dim}Tokens saved: ~${formatTokens(tokens)}${c.reset}`;
+    return `${c.dim}Session: ~${formatTokens(sessionTokens)} saved | Total: ~${formatTokens(state.tokensSaved)}${c.reset}`;
 }
-// Save state on exit
+export function getSessionId() {
+    return sessionId;
+}
+// Save state on exit — record session stats
 export function saveOnExit() {
+    if (sessionCommands > 0) {
+        state.sessions.push({
+            id: sessionId,
+            folder: sessionFolder,
+            startedAt: sessionStartedAt,
+            endedAt: new Date().toISOString(),
+            tokensSaved: sessionTokens,
+            commandsHandled: sessionCommands,
+        });
+    }
     saveState(state);
 }
 // ─── Helpers ────────────────────────────────────────────────────────────────

package/dist/utils/sessionSummary.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Session summary generator.
+ *
+ * Reads conversation turns from ~/.notoken/conversations/ and generates
+ * summaries of what was done in each session.
+ *
+ * Used by:
+ * - Desktop app dashboard session card
+ * - :sessions command in CLI
+ * - Exit summary
+ */
+export interface SessionSummary {
+    id: string;
+    folder: string;
+    startedAt: string;
+    endedAt: string;
+    turns: number;
+    commands: string[];
+    intents: string[];
+    entities: string[];
+    errors: number;
+    highlights: string[];
+}
+/**
+ * Get summaries for recent sessions across all folders.
+ */
+export declare function getRecentSessions(limit?: number): SessionSummary[];
+/**
+ * Get sessions for a specific folder.
+ */
+export declare function getSessionsForFolder(folder: string, limit?: number): SessionSummary[];
+/**
+ * Format a session summary for display.
+ */
+export declare function formatSessionSummary(session: SessionSummary): string;
+/**
+ * Format multiple sessions as a list.
+ */
+export declare function formatSessionList(sessions: SessionSummary[]): string;

package/dist/utils/sessionSummary.js

@@ -0,0 +1,185 @@
+/**
+ * Session summary generator.
+ *
+ * Reads conversation turns from ~/.notoken/conversations/ and generates
+ * summaries of what was done in each session.
+ *
+ * Used by:
+ * - Desktop app dashboard session card
+ * - :sessions command in CLI
+ * - Exit summary
+ */
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+const CONVERSATIONS_ROOT = resolve(homedir(), ".notoken", "conversations");
+/**
+ * Get summaries for recent sessions across all folders.
+ */
+export function getRecentSessions(limit = 20) {
+    const sessions = [];
+    if (!existsSync(CONVERSATIONS_ROOT))
+        return sessions;
+    // Walk all folder subdirectories
+    try {
+        const walkDir = (dir) => {
+            const entries = readdirSync(dir, { withFileTypes: true });
+            for (const entry of entries) {
+                const full = resolve(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walkDir(full);
+                }
+                else if (entry.name.endsWith(".json")) {
+                    try {
+                        const conv = JSON.parse(readFileSync(full, "utf-8"));
+                        if (conv.turns && conv.turns.length > 0) {
+                            sessions.push(summarizeConversation(conv, dir));
+                        }
+                    }
+                    catch { }
+                }
+            }
+        };
+        walkDir(CONVERSATIONS_ROOT);
+    }
+    catch { }
+    // Sort by most recent first
+    sessions.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+    return sessions.slice(0, limit);
+}
+/**
+ * Get sessions for a specific folder.
+ */
+export function getSessionsForFolder(folder, limit = 10) {
+    const safePath = folder.replace(/[^a-zA-Z0-9_\-\/]/g, "_").replace(/^\/+/, "");
+    const dir = resolve(CONVERSATIONS_ROOT, safePath || "default");
+    if (!existsSync(dir))
+        return [];
+    const sessions = [];
+    const files = readdirSync(dir).filter(f => f.endsWith(".json")).sort().reverse();
+    for (const file of files.slice(0, limit)) {
+        try {
+            const conv = JSON.parse(readFileSync(resolve(dir, file), "utf-8"));
+            if (conv.turns && conv.turns.length > 0) {
+                sessions.push(summarizeConversation(conv, folder));
+            }
+        }
+        catch { }
+    }
+    return sessions;
+}
+function summarizeConversation(conv, folder) {
+    const turns = conv.turns ?? [];
+    const userTurns = turns.filter(t => t.role === "user");
+    const systemTurns = turns.filter(t => t.role === "system");
+    // Extract unique intents
+    const intents = [...new Set(userTurns.map(t => t.intent).filter(Boolean))];
+    // Extract commands (raw text of user turns)
+    const commands = userTurns.map(t => t.rawText).filter(Boolean);
+    // Extract entities from knowledge tree
+    const knowledgeTree = conv.knowledgeTree ?? [];
+    const entities = knowledgeTree.map(e => `${e.entity} (${e.type})`);
+    // Count errors
+    const errors = systemTurns.filter(t => t.error).length;
+    // Generate highlights — most interesting things that happened
+    const highlights = [];
+    if (intents.includes("service.restart"))
+        highlights.push("Restarted services");
+    if (intents.includes("deploy.run"))
+        highlights.push("Deployed");
+    if (intents.includes("deploy.rollback"))
+        highlights.push("Rolled back deploy");
+    if (intents.some(i => i.startsWith("docker.")))
+        highlights.push("Docker operations");
+    if (intents.some(i => i.startsWith("git.")))
+        highlights.push("Git operations");
+    if (intents.some(i => i.startsWith("security.")))
+        highlights.push("Security checks");
+    if (intents.includes("server.check_disk"))
+        highlights.push("Disk check");
+    if (intents.includes("server.check_memory"))
+        highlights.push("Memory check");
+    if (intents.some(i => i.startsWith("logs.")))
+        highlights.push("Log inspection");
+    if (intents.some(i => i.startsWith("file.")))
+        highlights.push("File operations");
+    if (intents.some(i => i.startsWith("db.")))
+        highlights.push("Database operations");
+    if (intents.some(i => i.startsWith("backup.")))
+        highlights.push("Backup operations");
+    if (errors > 0)
+        highlights.push(`${errors} error(s)`);
+    // If no specific highlights, summarize by count
+    if (highlights.length === 0 && intents.length > 0) {
+        highlights.push(`${intents.length} different operations`);
+    }
+    return {
+        id: conv.id ?? "unknown",
+        folder,
+        startedAt: conv.createdAt ?? "",
+        endedAt: conv.updatedAt ?? "",
+        turns: turns.length,
+        commands: commands.slice(0, 10),
+        intents,
+        entities: entities.slice(0, 10),
+        errors,
+        highlights,
+    };
+}
+/**
+ * Format a session summary for display.
+ */
+export function formatSessionSummary(session) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m", yellow: "\x1b[33m", red: "\x1b[31m" };
+    const ago = timeAgo(session.startedAt);
+    const duration = timeBetween(session.startedAt, session.endedAt);
+    const errorTag = session.errors > 0 ? ` ${c.red}(${session.errors} errors)${c.reset}` : "";
+    const lines = [];
+    lines.push(`${c.bold}${ago}${c.reset} — ${duration}${errorTag}`);
+    lines.push(`${c.dim}${session.folder} | ${session.turns} turns | ${session.id}${c.reset}`);
+    if (session.highlights.length > 0) {
+        lines.push(`${c.cyan}${session.highlights.join(" · ")}${c.reset}`);
+    }
+    if (session.commands.length > 0) {
+        lines.push(`${c.dim}Commands: ${session.commands.slice(0, 5).join(", ")}${session.commands.length > 5 ? "..." : ""}${c.reset}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Format multiple sessions as a list.
+ */
+export function formatSessionList(sessions) {
+    if (sessions.length === 0)
+        return "\x1b[2mNo sessions found.\x1b[0m";
+    return sessions.map((s, i) => {
+        const sep = i < sessions.length - 1 ? "\n" : "";
+        return `  ${formatSessionSummary(s)}${sep}`;
+    }).join("\n");
+}
+function timeAgo(dateStr) {
+    const ms = Date.now() - new Date(dateStr).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 1)
+        return "Just now";
+    if (mins < 60)
+        return `${mins}m ago`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ago`;
+    const days = Math.floor(hours / 24);
+    if (days < 7)
+        return `${days}d ago`;
+    return new Date(dateStr).toLocaleDateString();
+}
+function timeBetween(start, end) {
+    const ms = new Date(end).getTime() - new Date(start).getTime();
+    const mins = Math.floor(ms / 60000);
+    if (mins < 1)
+        return "<1m";
+    if (mins < 60)
+        return `${mins}m`;
+    const hours = Math.floor(mins / 60);
+    if (hours < 24)
+        return `${hours}h ${mins % 60}m`;
+    return `${Math.floor(hours / 24)}d`;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "notoken-core",
-  "version": "1.4.0",
+  "version": "1.5.0",
   "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
   "type": "module",
   "license": "MIT",