notoken-core 1.4.1 → 1.5.1

package/dist/index.d.ts

@@ -45,7 +45,9 @@ 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 { isSessionOpen, toggleSession, hideSession, unhideSession, getHiddenSessions, getLastViewedSession, createFullBackup, restoreFromBackup, listFullBackups, formatBackupsList, type BackupInfo, } from "./utils/sessionBackup.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,11 @@ 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";
+// ── Session Backup & Prefs ──
+export { isSessionOpen, toggleSession, hideSession, unhideSession, getHiddenSessions, getLastViewedSession, createFullBackup, restoreFromBackup, listFullBackups, formatBackupsList, } from "./utils/sessionBackup.js";
 // ── Logging ──
 export { logFailure, loadFailures, clearFailures } from "./utils/logger.js";
 export { logUncertainty, loadUncertaintyLog, getUncertaintySummary } from "./nlp/uncertainty.js";

package/dist/utils/sessionBackup.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Session backup and restore.
+ *
+ * Backup: tars ~/.notoken/ into a timestamped archive
+ * Restore: extracts an archive back to ~/.notoken/
+ * Manages open/closed state per session for the dashboard
+ */
+export declare function isSessionOpen(sessionId: string): boolean;
+export declare function toggleSession(sessionId: string): boolean;
+export declare function hideSession(sessionId: string): void;
+export declare function unhideSession(sessionId: string): void;
+export declare function getHiddenSessions(): string[];
+export declare function getLastViewedSession(): string | undefined;
+export interface BackupInfo {
+    path: string;
+    filename: string;
+    size: string;
+    createdAt: string;
+}
+/**
+ * Create a full backup of ~/.notoken/ as a tar.gz archive.
+ * Saves to ~/.notoken/backups/ by default, or a custom path.
+ */
+export declare function createFullBackup(outputDir?: string): BackupInfo;
+/**
+ * Restore from a backup archive.
+ * Creates a safety backup of current state first.
+ */
+export declare function restoreFromBackup(archivePath: string): {
+    success: boolean;
+    message: string;
+};
+/**
+ * List available backups.
+ */
+export declare function listFullBackups(): BackupInfo[];
+/**
+ * Format backup list for display.
+ */
+export declare function formatBackupsList(backups: BackupInfo[]): string;

package/dist/utils/sessionBackup.js

@@ -0,0 +1,181 @@
+/**
+ * Session backup and restore.
+ *
+ * Backup: tars ~/.notoken/ into a timestamped archive
+ * Restore: extracts an archive back to ~/.notoken/
+ * Manages open/closed state per session for the dashboard
+ */
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve, basename } from "node:path";
+import { USER_HOME } from "./paths.js";
+const PREFS_FILE = resolve(USER_HOME, "session-prefs.json");
+const BACKUP_DIR = resolve(USER_HOME, "backups");
+function loadPrefs() {
+    try {
+        if (existsSync(PREFS_FILE))
+            return JSON.parse(readFileSync(PREFS_FILE, "utf-8"));
+    }
+    catch { }
+    return { openSessions: [], hiddenSessions: [] };
+}
+function savePrefs(prefs) {
+    try {
+        mkdirSync(USER_HOME, { recursive: true });
+        writeFileSync(PREFS_FILE, JSON.stringify(prefs, null, 2));
+    }
+    catch { }
+}
+export function isSessionOpen(sessionId) {
+    return loadPrefs().openSessions.includes(sessionId);
+}
+export function toggleSession(sessionId) {
+    const prefs = loadPrefs();
+    const idx = prefs.openSessions.indexOf(sessionId);
+    if (idx >= 0) {
+        prefs.openSessions.splice(idx, 1);
+        savePrefs(prefs);
+        return false;
+    }
+    else {
+        prefs.openSessions.push(sessionId);
+        prefs.lastViewed = sessionId;
+        savePrefs(prefs);
+        return true;
+    }
+}
+export function hideSession(sessionId) {
+    const prefs = loadPrefs();
+    if (!prefs.hiddenSessions.includes(sessionId)) {
+        prefs.hiddenSessions.push(sessionId);
+    }
+    prefs.openSessions = prefs.openSessions.filter(s => s !== sessionId);
+    savePrefs(prefs);
+}
+export function unhideSession(sessionId) {
+    const prefs = loadPrefs();
+    prefs.hiddenSessions = prefs.hiddenSessions.filter(s => s !== sessionId);
+    savePrefs(prefs);
+}
+export function getHiddenSessions() {
+    return loadPrefs().hiddenSessions;
+}
+export function getLastViewedSession() {
+    return loadPrefs().lastViewed;
+}
+/**
+ * Create a full backup of ~/.notoken/ as a tar.gz archive.
+ * Saves to ~/.notoken/backups/ by default, or a custom path.
+ */
+export function createFullBackup(outputDir) {
+    const dir = outputDir ?? BACKUP_DIR;
+    mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const filename = `notoken-backup-${ts}.tar.gz`;
+    const fullPath = resolve(dir, filename);
+    // Tar everything except the backups directory itself
+    execSync(`tar -czf "${fullPath}" -C "${resolve(USER_HOME, "..")}" --exclude="backups" "${basename(USER_HOME)}"`, { timeout: 60_000, stdio: "pipe" });
+    const size = tryExec(`ls -lh "${fullPath}" | awk '{print $5}'`) ?? "unknown";
+    return {
+        path: fullPath,
+        filename,
+        size,
+        createdAt: new Date().toISOString(),
+    };
+}
+/**
+ * Restore from a backup archive.
+ * Creates a safety backup of current state first.
+ */
+export function restoreFromBackup(archivePath) {
+    if (!existsSync(archivePath)) {
+        return { success: false, message: `Backup not found: ${archivePath}` };
+    }
+    // Safety backup of current state
+    try {
+        const safety = createFullBackup();
+        console.error(`\x1b[2m[backup] Safety backup created: ${safety.path}\x1b[0m`);
+    }
+    catch { }
+    // Extract
+    try {
+        execSync(`tar -xzf "${archivePath}" -C "${resolve(USER_HOME, "..")}"`, { timeout: 60_000, stdio: "pipe" });
+        return { success: true, message: `Restored from ${basename(archivePath)}` };
+    }
+    catch (err) {
+        return { success: false, message: `Restore failed: ${err.message}` };
+    }
+}
+/**
+ * List available backups.
+ */
+export function listFullBackups() {
+    if (!existsSync(BACKUP_DIR))
+        return [];
+    try {
+        const { readdirSync, statSync } = require("node:fs");
+        return readdirSync(BACKUP_DIR)
+            .filter((f) => f.startsWith("notoken-backup-") && f.endsWith(".tar.gz"))
+            .map((f) => {
+            const full = resolve(BACKUP_DIR, f);
+            const stat = statSync(full);
+            return {
+                path: full,
+                filename: f,
+                size: formatSize(stat.size),
+                createdAt: stat.mtime.toISOString(),
+            };
+        })
+            .sort((a, b) => b.createdAt.localeCompare(a.createdAt));
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Format backup list for display.
+ */
+export function formatBackupsList(backups) {
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m" };
+    if (backups.length === 0)
+        return `${c.dim}No backups found.${c.reset}`;
+    const lines = [`${c.bold}Backups:${c.reset}\n`];
+    for (const b of backups) {
+        const ago = timeAgo(b.createdAt);
+        lines.push(`  ${c.cyan}${b.filename}${c.reset} — ${b.size} — ${ago}`);
+    }
+    lines.push(`\n  ${c.dim}Backup dir: ${BACKUP_DIR}${c.reset}`);
+    lines.push(`  ${c.dim}Restore: notoken restore <filename>${c.reset}`);
+    return lines.join("\n");
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function formatSize(bytes) {
+    if (bytes < 1024)
+        return `${bytes} B`;
+    if (bytes < 1048576)
+        return `${(bytes / 1024).toFixed(1)} KB`;
+    if (bytes < 1073741824)
+        return `${(bytes / 1048576).toFixed(1)} MB`;
+    return `${(bytes / 1073741824).toFixed(1)} GB`;
+}
+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);
+    return `${days}d ago`;
+}
+function tryExec(cmd) {
+    try {
+        return execSync(cmd, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"], timeout: 10_000 }).trim() || null;
+    }
+    catch {
+        return null;
+    }
+}

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.1",
+  "version": "1.5.1",
   "description": "Shared engine for notoken — NLP parsing, execution, detection, analysis",
   "type": "module",
   "license": "MIT",