notoken-core 1.6.0 → 2.0.0

package/dist/conversation/store.d.ts

@@ -27,6 +27,22 @@ export interface UncertaintyReport {
     }>;
     overallConfidence: number;
 }
+export interface EntityFocus {
+    /** The entity/installation currently being discussed */
+    entityId: string;
+    /** What type — "installation", "server", "database", "service" */
+    entityType: string;
+    /** When it became the focus */
+    focusedAt: string;
+    /** Turn ID when it became the focus */
+    focusedAtTurn: number;
+    /** Conversation history of discussed entities (most recent first) */
+    history: Array<{
+        entityId: string;
+        entityType: string;
+        turnId: number;
+    }>;
+}
 export interface Conversation {
     id: string;
     folderPath: string;
@@ -35,6 +51,15 @@ export interface Conversation {
     turns: ConversationTurn[];
     /** Running knowledge of entities mentioned across turns */
     knowledgeTree: KnowledgeNode[];
+    /** Currently focused entity — for "it", "that one", "restart it" resolution */
+    focus?: EntityFocus;
+    /** Files loaded into context — content available to LLM and command analysis */
+    contextFiles?: Array<{
+        path: string;
+        name: string;
+        content: string;
+        loadedAt: string;
+    }>;
 }
 export interface KnowledgeNode {
     entity: string;
@@ -80,6 +105,53 @@ export declare function addUserTurn(conv: Conversation, rawText: string, intent?
  * Add a system result turn.
  */
 export declare function addSystemTurn(conv: Conversation, rawText: string, result?: string, error?: string): ConversationTurn;
+/**
+ * Set the currently discussed entity. Called when the user explicitly
+ * references an entity/installation (e.g., "the windows openclaw",
+ * "openclaw #2", "start openclaw on windows").
+ */
+export declare function setEntityFocus(conv: Conversation, entityId: string, entityType: string, turnId?: number): void;
+/**
+ * Get the currently focused entity.
+ * Returns null if nothing is focused or focus is stale.
+ * Staleness = too many turns have passed without re-mentioning the entity.
+ * (Not wall-clock time — if user leaves and comes back, focus is still valid.)
+ */
+export declare function getEntityFocus(conv: Conversation, maxTurnsSinceFocus?: number): EntityFocus | null;
+/**
+ * Get the previously discussed entity (for "the other one" resolution).
+ * Returns the entity that was focused before the current one.
+ */
+export declare function getPreviousFocus(conv: Conversation): {
+    entityId: string;
+    entityType: string;
+} | null;
+/**
+ * Resolve "it", "that one", "this one" to the focused entity.
+ * Resolve "the other one" to the previously focused entity.
+ */
+export declare function resolveFocusReference(conv: Conversation, text: string): {
+    entityId: string;
+    entityType: string;
+} | null;
+/**
+ * Load a file into the conversation context.
+ * Content is stored and available to LLM fallback and analysis.
+ * Max 50KB per file to avoid bloating conversation store.
+ */
+export declare function loadContextFile(conv: Conversation, filePath: string): string;
+/**
+ * Unload a file from context.
+ */
+export declare function unloadContextFile(conv: Conversation, fileName: string): string;
+/**
+ * List loaded context files.
+ */
+export declare function listContextFiles(conv: Conversation): string;
+/**
+ * Get all context file contents as a single string for LLM prompts.
+ */
+export declare function getContextFilesContent(conv: Conversation): string;
 /**
  * Get the most recently mentioned entity of a given type.
  */

package/dist/conversation/store.js

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync } from "node:fs";
-import { resolve } from "node:path";
+import { resolve, basename } from "node:path";
 import { homedir } from "node:os";
 const CONVERSATIONS_ROOT = resolve(homedir(), ".notoken", "conversations");
 // ─── Store ───────────────────────────────────────────────────────────────────
@@ -158,6 +158,145 @@ function updateKnowledge(conv, entity, turnId, fields) {
         }
     }
 }
+// ─── Entity Focus ──────────────────────────────────────────────────────────
+/**
+ * Set the currently discussed entity. Called when the user explicitly
+ * references an entity/installation (e.g., "the windows openclaw",
+ * "openclaw #2", "start openclaw on windows").
+ */
+export function setEntityFocus(conv, entityId, entityType, turnId) {
+    const turn = turnId ?? conv.turns.length;
+    const entry = { entityId, entityType, turnId: turn };
+    if (!conv.focus) {
+        conv.focus = { entityId, entityType, focusedAt: new Date().toISOString(), focusedAtTurn: turn, history: [] };
+    }
+    else {
+        // Push previous focus to history
+        if (conv.focus.entityId !== entityId) {
+            conv.focus.history.unshift({ entityId: conv.focus.entityId, entityType: conv.focus.entityType, turnId: conv.focus.focusedAtTurn });
+            // Keep last 10
+            if (conv.focus.history.length > 10)
+                conv.focus.history = conv.focus.history.slice(0, 10);
+        }
+        conv.focus.entityId = entityId;
+        conv.focus.entityType = entityType;
+        conv.focus.focusedAt = new Date().toISOString();
+        conv.focus.focusedAtTurn = turn;
+    }
+    saveConversation(conv);
+}
+/**
+ * Get the currently focused entity.
+ * Returns null if nothing is focused or focus is stale.
+ * Staleness = too many turns have passed without re-mentioning the entity.
+ * (Not wall-clock time — if user leaves and comes back, focus is still valid.)
+ */
+export function getEntityFocus(conv, maxTurnsSinceFocus = 8) {
+    if (!conv.focus)
+        return null;
+    // Focus expires after N turns without re-mentioning
+    const turnsSinceFocus = conv.turns.length - conv.focus.focusedAtTurn;
+    if (turnsSinceFocus > maxTurnsSinceFocus)
+        return null;
+    return conv.focus;
+}
+/**
+ * Get the previously discussed entity (for "the other one" resolution).
+ * Returns the entity that was focused before the current one.
+ */
+export function getPreviousFocus(conv) {
+    if (!conv.focus?.history?.length)
+        return null;
+    return conv.focus.history[0];
+}
+/**
+ * Resolve "it", "that one", "this one" to the focused entity.
+ * Resolve "the other one" to the previously focused entity.
+ */
+export function resolveFocusReference(conv, text) {
+    const lower = text.toLowerCase();
+    // "the other one", "the previous one", "not this one"
+    if (/\bthe\s+other\s+(one|entity|install|openclaw|ollama)\b|\bnot\s+this\s+one\b|\bthe\s+previous\s+one\b/.test(lower)) {
+        return getPreviousFocus(conv);
+    }
+    // "it", "this one", "that one", "the same one" — return current focus
+    if (/\b(restart|stop|start|check|update|configure|diagnose|fix)\s+(it|this|that)\b|\bthis\s+one\b|\bthat\s+one\b|\bthe\s+same\s+one\b/.test(lower)) {
+        const focus = getEntityFocus(conv);
+        if (focus)
+            return { entityId: focus.entityId, entityType: focus.entityType };
+    }
+    return null;
+}
+// ─── Context Files ──────────────────────────────────────────────────────────
+/**
+ * Load a file into the conversation context.
+ * Content is stored and available to LLM fallback and analysis.
+ * Max 50KB per file to avoid bloating conversation store.
+ */
+export function loadContextFile(conv, filePath) {
+    const absPath = resolve(filePath);
+    if (!existsSync(absPath)) {
+        return `File not found: ${absPath}`;
+    }
+    const stat = require("node:fs").statSync(absPath);
+    if (stat.size > 50 * 1024) {
+        return `File too large (${(stat.size / 1024).toFixed(0)} KB). Max 50 KB for context files. Use file.read for large files.`;
+    }
+    const content = readFileSync(absPath, "utf-8");
+    const name = basename(absPath);
+    if (!conv.contextFiles)
+        conv.contextFiles = [];
+    // Replace if already loaded
+    const existing = conv.contextFiles.findIndex((f) => f.path === absPath);
+    if (existing >= 0) {
+        conv.contextFiles[existing] = { path: absPath, name, content, loadedAt: new Date().toISOString() };
+    }
+    else {
+        conv.contextFiles.push({ path: absPath, name, content, loadedAt: new Date().toISOString() });
+    }
+    saveConversation(conv);
+    return `Loaded ${name} (${content.split("\n").length} lines, ${(stat.size / 1024).toFixed(1)} KB) into context.`;
+}
+/**
+ * Unload a file from context.
+ */
+export function unloadContextFile(conv, fileName) {
+    if (!conv.contextFiles?.length)
+        return "No context files loaded.";
+    const idx = conv.contextFiles.findIndex((f) => f.name === fileName || f.path.endsWith(fileName));
+    if (idx < 0)
+        return `Not in context: ${fileName}`;
+    const removed = conv.contextFiles.splice(idx, 1)[0];
+    saveConversation(conv);
+    return `Removed ${removed.name} from context.`;
+}
+/**
+ * List loaded context files.
+ */
+export function listContextFiles(conv) {
+    if (!conv.contextFiles?.length)
+        return "No context files loaded.";
+    const c = { reset: "\x1b[0m", bold: "\x1b[1m", dim: "\x1b[2m", cyan: "\x1b[36m", green: "\x1b[32m" };
+    const lines = [`\n${c.bold}${c.cyan}── Context Files ──${c.reset}\n`];
+    for (const f of conv.contextFiles) {
+        const lineCount = f.content.split("\n").length;
+        const sizeKB = (Buffer.byteLength(f.content) / 1024).toFixed(1);
+        lines.push(`  ${c.green}✓${c.reset} ${c.bold}${f.name}${c.reset}  ${c.dim}(${lineCount} lines, ${sizeKB} KB, loaded ${new Date(f.loadedAt).toLocaleString()})${c.reset}`);
+        lines.push(`    ${c.dim}${f.path}${c.reset}`);
+    }
+    lines.push(`\n${c.dim}To unload: :context unload <filename>${c.reset}`);
+    return lines.join("\n");
+}
+/**
+ * Get all context file contents as a single string for LLM prompts.
+ */
+export function getContextFilesContent(conv) {
+    if (!conv.contextFiles?.length)
+        return "";
+    return conv.contextFiles
+        .map((f) => `=== ${f.name} ===\n${f.content}`)
+        .join("\n\n");
+}
 /**
  * Get the most recently mentioned entity of a given type.
  */

package/dist/conversation/topicTracker.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Topic Tracker — tracks what domain the conversation is about.
+ *
+ * If the user has been talking about Docker for 5 turns, bare commands
+ * like "check status" or "restart" should default to Docker context.
+ *
+ * Also provides suggested follow-up commands based on what was just done.
+ */
+import type { Conversation } from "./store.js";
+export interface TopicContext {
+    /** Current dominant topic */
+    topic: string | null;
+    /** How many consecutive turns on this topic */
+    depth: number;
+    /** Confidence that this is the active topic (0-1) */
+    confidence: number;
+    /** Recent topics with counts */
+    recentTopics: Array<{
+        topic: string;
+        count: number;
+    }>;
+}
+/**
+ * Analyze recent conversation to determine the current topic.
+ */
+export declare function getCurrentTopic(conv: Conversation, lookback?: number): TopicContext;
+/**
+ * Suggest follow-up commands based on what was just executed.
+ */
+export declare function suggestFollowups(intent: string): string[];
+/**
+ * Get topic-aware default for ambiguous commands.
+ * "check status" during a Docker conversation → docker.list
+ * "restart" during a services conversation → service.restart
+ */
+export declare function getTopicDefault(ambiguousVerb: string, topic: TopicContext): string | null;

package/dist/conversation/topicTracker.js

@@ -0,0 +1,141 @@
+/**
+ * Topic Tracker — tracks what domain the conversation is about.
+ *
+ * If the user has been talking about Docker for 5 turns, bare commands
+ * like "check status" or "restart" should default to Docker context.
+ *
+ * Also provides suggested follow-up commands based on what was just done.
+ */
+// ─── Topic detection ────────────────────────────────────────────────────────
+const INTENT_TO_TOPIC = {
+    "docker.": "docker",
+    "service.": "services",
+    "server.": "system",
+    "disk.": "disk",
+    "logs.": "logs",
+    "network.": "network",
+    "git.": "git",
+    "deploy.": "deploy",
+    "openclaw.": "openclaw",
+    "discord.": "discord",
+    "ollama.": "ollama",
+    "security.": "security",
+    "db.": "database",
+    "backup.": "backup",
+    "user.": "users",
+    "firewall.": "firewall",
+    "cron.": "cron",
+    "files.": "files",
+    "process.": "processes",
+    "ai.": "ai",
+    "notoken.": "notoken",
+    "weather.": "general",
+    "news.": "general",
+};
+function intentToTopic(intent) {
+    for (const [prefix, topic] of Object.entries(INTENT_TO_TOPIC)) {
+        if (intent.startsWith(prefix))
+            return topic;
+    }
+    return null;
+}
+/**
+ * Analyze recent conversation to determine the current topic.
+ */
+export function getCurrentTopic(conv, lookback = 8) {
+    const recent = conv.turns.slice(-lookback).filter(t => t.role === "user" && t.intent);
+    if (recent.length === 0)
+        return { topic: null, depth: 0, confidence: 0, recentTopics: [] };
+    // Count topics in recent turns
+    const topicCounts = new Map();
+    let consecutiveCount = 0;
+    let lastTopic = null;
+    for (const turn of recent.reverse()) {
+        const topic = intentToTopic(turn.intent);
+        if (!topic)
+            continue;
+        topicCounts.set(topic, (topicCounts.get(topic) ?? 0) + 1);
+        if (lastTopic === null) {
+            lastTopic = topic;
+            consecutiveCount = 1;
+        }
+        else if (topic === lastTopic) {
+            consecutiveCount++;
+        }
+    }
+    if (!lastTopic)
+        return { topic: null, depth: 0, confidence: 0, recentTopics: [] };
+    // Most frequent topic
+    const sorted = [...topicCounts.entries()].sort((a, b) => b[1] - a[1]);
+    const dominantTopic = sorted[0][0];
+    const dominantCount = sorted[0][1];
+    // Confidence based on dominance ratio and consecutive turns
+    const confidence = Math.min(1.0, (dominantCount / recent.length) * 0.6 +
+        (consecutiveCount / Math.min(recent.length, 5)) * 0.4);
+    return {
+        topic: dominantTopic,
+        depth: consecutiveCount,
+        confidence,
+        recentTopics: sorted.map(([topic, count]) => ({ topic, count })),
+    };
+}
+// ─── Suggested commands ─────────────────────────────────────────────────────
+const SUGGESTIONS = {
+    "service.restart": ["check service status", "show logs", "is it running now"],
+    "service.status": ["restart service", "show logs", "check memory"],
+    "server.check_disk": ["free up space", "scan drives", "show large files"],
+    "server.uptime": ["check memory", "list processes", "check disk"],
+    "server.check_memory": ["list processes", "check disk", "kill process"],
+    "disk.cleanup": ["check disk space", "scan drives"],
+    "disk.scan": ["free up space", "check disk space"],
+    "docker.list": ["docker logs", "restart container", "docker images"],
+    "docker.restart": ["docker list", "docker logs", "check status"],
+    "logs.tail": ["search logs for errors", "show error logs"],
+    "logs.errors": ["show full logs", "restart service", "check status"],
+    "deploy.run": ["check status", "rollback deploy", "show logs"],
+    "network.ports": ["check firewall rules", "block ip", "scan for attacks"],
+    "security.scan": ["check firewall rules", "install fail2ban", "block ip"],
+    "git.status": ["git log", "git pull", "git diff"],
+    "git.pull": ["git status", "git log"],
+    "process.list": ["kill process", "check memory", "check load"],
+    "process.kill": ["list processes", "check memory"],
+    "backup.create": ["list backups", "check disk space"],
+    "ai.generate_image": ["check image status", "generate another image"],
+    "openclaw.status": ["diagnose openclaw", "restart openclaw"],
+    "openclaw.diagnose": ["fix openclaw", "restart openclaw"],
+    "weather.current": ["news headlines"],
+    "notoken.status": ["check disk", "check load", "show running services"],
+};
+/**
+ * Suggest follow-up commands based on what was just executed.
+ */
+export function suggestFollowups(intent) {
+    return SUGGESTIONS[intent] ?? [];
+}
+/**
+ * Get topic-aware default for ambiguous commands.
+ * "check status" during a Docker conversation → docker.list
+ * "restart" during a services conversation → service.restart
+ */
+export function getTopicDefault(ambiguousVerb, topic) {
+    if (!topic.topic || topic.confidence < 0.4)
+        return null;
+    const defaults = {
+        docker: { status: "docker.list", restart: "docker.restart", stop: "docker.stop", logs: "docker.logs", list: "docker.list" },
+        services: { status: "service.status", restart: "service.restart", stop: "service.stop", start: "service.start", check: "service.status" },
+        system: { status: "server.uptime", check: "server.uptime" },
+        disk: { status: "server.check_disk", check: "server.check_disk", clean: "disk.cleanup", scan: "disk.scan" },
+        logs: { show: "logs.tail", check: "logs.errors", search: "logs.search" },
+        network: { check: "network.ports", scan: "network.ports", status: "network.ports" },
+        git: { status: "git.status", check: "git.status" },
+        security: { check: "security.scan", scan: "security.scan" },
+        database: { check: "db.size", status: "db.tables" },
+        openclaw: { status: "openclaw.status", check: "openclaw.status", restart: "openclaw.restart", diagnose: "openclaw.diagnose" },
+        discord: { status: "discord.check", check: "discord.check", diagnose: "discord.diagnose" },
+    };
+    const topicDefaults = defaults[topic.topic];
+    if (!topicDefaults)
+        return null;
+    const verb = ambiguousVerb.toLowerCase().trim();
+    return topicDefaults[verb] ?? null;
+}

package/dist/execution/ssh.d.ts

@@ -1,2 +1,43 @@
+/**
+ * SSH / local / Docker execution layer.
+ *
+ * Uses the `ssh2` npm package for all remote connections:
+ * - Password auth (no sshpass/expect/plink needed)
+ * - Key-based auth (reads key file directly)
+ * - SSH agent forwarding
+ * - Reads ~/.ssh/config for host aliases, keys, ports
+ *
+ * Falls back to system `ssh` binary only if ssh2 fails unexpectedly.
+ */
+export interface HostEntry {
+    host: string;
+    description: string;
+    port?: number;
+    key?: string;
+    password?: string;
+    /** Path to a credentials file. Format: first line = username, second line = password */
+    credentialsFile?: string;
+}
 export declare function runRemoteCommand(environment: string, command: string): Promise<string>;
-export declare function runLocalCommand(command: string): Promise<string>;
+export declare function runLocalCommand(command: string, timeout?: number): Promise<string>;
+/**
+ * Run a command inside a Docker container.
+ */
+export declare function runDockerExec(container: string, command: string): Promise<string>;
+/**
+ * Test SSH connectivity to a host. Returns formatted status.
+ */
+export declare function testSshConnection(environment: string): Promise<string>;
+export interface TransferProgress {
+    file: string;
+    bytesTransferred: number;
+    totalBytes: number;
+    filesCompleted: number;
+    totalFiles: number;
+}
+export type TransferDirection = "upload" | "download";
+/**
+ * Transfer files to/from a remote host via SFTP.
+ * Supports single files and recursive directories.
+ */
+export declare function sftpTransfer(environment: string, localPath: string, remotePath: string, direction: TransferDirection, onProgress?: (progress: TransferProgress) => void): Promise<string>;