notoken-core 1.0.0

package/dist/agents/playbookRunner.d.ts

@@ -0,0 +1,45 @@
+/**
+ * Playbook runner.
+ *
+ * Loads playbooks from config/playbooks.json and executes them
+ * step by step, locally or remotely.
+ */
+export interface PlaybookStep {
+    command: string;
+    label: string;
+}
+export interface Playbook {
+    name: string;
+    description: string;
+    steps: PlaybookStep[];
+}
+export interface PlaybookResult {
+    name: string;
+    environment: string;
+    steps: Array<{
+        label: string;
+        command: string;
+        output: string;
+        success: boolean;
+        durationMs: number;
+    }>;
+    totalDurationMs: number;
+}
+/**
+ * Load all playbooks from config.
+ */
+export declare function loadPlaybooks(): Playbook[];
+/**
+ * Get a playbook by name.
+ */
+export declare function getPlaybook(name: string): Playbook | undefined;
+/**
+ * List all available playbooks.
+ */
+export declare function formatPlaybookList(): string;
+/**
+ * Execute a playbook step by step.
+ */
+export declare function runPlaybook(playbook: Playbook, environment?: string, options?: {
+    dryRun?: boolean;
+}): Promise<PlaybookResult>;

package/dist/agents/playbookRunner.js

@@ -0,0 +1,120 @@
+/**
+ * Playbook runner.
+ *
+ * Loads playbooks from config/playbooks.json and executes them
+ * step by step, locally or remotely.
+ */
+import { readFileSync, existsSync } from "node:fs";
+import { resolve } from "node:path";
+import { runRemoteCommand, runLocalCommand } from "../execution/ssh.js";
+import { CONFIG_DIR } from "../utils/paths.js";
+const PLAYBOOKS_FILE = resolve(CONFIG_DIR, "playbooks.json");
+const c = {
+    reset: "\x1b[0m",
+    bold: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    cyan: "\x1b[36m",
+};
+/**
+ * Load all playbooks from config.
+ */
+export function loadPlaybooks() {
+    if (!existsSync(PLAYBOOKS_FILE))
+        return [];
+    const raw = JSON.parse(readFileSync(PLAYBOOKS_FILE, "utf-8"));
+    return raw.playbooks ?? [];
+}
+/**
+ * Get a playbook by name.
+ */
+export function getPlaybook(name) {
+    return loadPlaybooks().find((p) => p.name === name || p.name.includes(name));
+}
+/**
+ * List all available playbooks.
+ */
+export function formatPlaybookList() {
+    const playbooks = loadPlaybooks();
+    if (playbooks.length === 0)
+        return `${c.dim}No playbooks configured.${c.reset}`;
+    const lines = [`${c.bold}Available playbooks:${c.reset}\n`];
+    for (const pb of playbooks) {
+        lines.push(`  ${c.cyan}${pb.name}${c.reset} — ${pb.description} (${pb.steps.length} steps)`);
+    }
+    lines.push(`\n  ${c.dim}Run: :play <name> [environment]${c.reset}`);
+    return lines.join("\n");
+}
+/**
+ * Execute a playbook step by step.
+ */
+export async function runPlaybook(playbook, environment, options = {}) {
+    const env = environment ?? "dev";
+    const isRemote = env !== "local";
+    console.log(`\n${c.bold}${c.cyan}Playbook: ${playbook.name}${c.reset}`);
+    console.log(`${c.dim}${playbook.description}${c.reset}`);
+    console.log(`${c.dim}Target: ${env} | ${playbook.steps.length} steps${c.reset}\n`);
+    const result = {
+        name: playbook.name,
+        environment: env,
+        steps: [],
+        totalDurationMs: 0,
+    };
+    const totalStart = Date.now();
+    for (let i = 0; i < playbook.steps.length; i++) {
+        const step = playbook.steps[i];
+        const stepNum = `[${i + 1}/${playbook.steps.length}]`;
+        console.log(`${c.cyan}${stepNum}${c.reset} ${step.label}...`);
+        if (options.dryRun) {
+            console.log(`  ${c.dim}$ ${step.command}${c.reset}\n`);
+            result.steps.push({
+                label: step.label,
+                command: step.command,
+                output: "[dry-run]",
+                success: true,
+                durationMs: 0,
+            });
+            continue;
+        }
+        const start = Date.now();
+        try {
+            const output = isRemote
+                ? await runRemoteCommand(env, step.command)
+                : await runLocalCommand(step.command);
+            const duration = Date.now() - start;
+            // Indent output
+            const indented = output.trim().split("\n").map((l) => `  ${l}`).join("\n");
+            console.log(`${indented}`);
+            console.log(`  ${c.green}✓${c.reset} ${c.dim}(${duration}ms)${c.reset}\n`);
+            result.steps.push({
+                label: step.label,
+                command: step.command,
+                output: output.trim(),
+                success: true,
+                durationMs: duration,
+            });
+        }
+        catch (err) {
+            const duration = Date.now() - start;
+            const msg = err instanceof Error ? err.message : String(err);
+            console.log(`  ${c.red}✗ ${msg.split("\n")[0]}${c.reset}`);
+            console.log(`  ${c.dim}(${duration}ms)${c.reset}\n`);
+            result.steps.push({
+                label: step.label,
+                command: step.command,
+                output: msg,
+                success: false,
+                durationMs: duration,
+            });
+        }
+    }
+    result.totalDurationMs = Date.now() - totalStart;
+    // Summary
+    const passed = result.steps.filter((s) => s.success).length;
+    const failed = result.steps.filter((s) => !s.success).length;
+    const icon = failed === 0 ? `${c.green}✓${c.reset}` : `${c.yellow}⚠${c.reset}`;
+    console.log(`${icon} ${c.bold}Playbook complete:${c.reset} ${passed} passed, ${failed} failed (${(result.totalDurationMs / 1000).toFixed(1)}s)`);
+    return result;
+}

package/dist/agents/taskRunner.d.ts

@@ -0,0 +1,61 @@
+import { EventEmitter } from "node:events";
+import type { DynamicIntent } from "../types/intent.js";
+export type TaskStatus = "pending" | "running" | "completed" | "failed" | "cancelled";
+export interface BackgroundTask {
+    id: number;
+    rawText: string;
+    intent: DynamicIntent;
+    status: TaskStatus;
+    startedAt: Date;
+    completedAt?: Date;
+    result?: string;
+    error?: string;
+    /** If true, the user has seen the completion notification */
+    acknowledged: boolean;
+}
+/**
+ * TaskRunner — manages background execution of CLI commands.
+ *
+ * Emits events:
+ *   "task:started"   (task)
+ *   "task:completed"  (task)
+ *   "task:failed"     (task)
+ *
+ * The interactive REPL listens to these events and prints
+ * notifications between prompts.
+ */
+export declare class TaskRunner extends EventEmitter {
+    private tasks;
+    private nextId;
+    private maxConcurrent;
+    private runningCount;
+    private queue;
+    constructor(maxConcurrent?: number);
+    /**
+     * Submit a task for background execution.
+     * Returns the task ID immediately.
+     */
+    submit(rawText: string, intent: DynamicIntent, executor: () => Promise<string>): BackgroundTask;
+    private run;
+    private drainQueue;
+    /** Cancel a pending or running task (best-effort). */
+    cancel(id: number): boolean;
+    /** Get a task by ID. */
+    get(id: number): BackgroundTask | undefined;
+    /** List all tasks, optionally filtered by status. */
+    list(filter?: TaskStatus): BackgroundTask[];
+    /** Get tasks that completed since the user last checked. */
+    getUnacknowledged(): BackgroundTask[];
+    /** Mark a task as seen by the user. */
+    acknowledge(id: number): void;
+    /** Acknowledge all completed tasks. */
+    acknowledgeAll(): void;
+    /** Clear completed/failed/cancelled tasks from the list. */
+    prune(): number;
+    /** How many tasks are currently running? */
+    get active(): number;
+    /** How many tasks are in the queue? */
+    get queued(): number;
+}
+/** Singleton instance used by the interactive CLI. */
+export declare const taskRunner: TaskRunner;

package/dist/agents/taskRunner.js

@@ -0,0 +1,142 @@
+import { EventEmitter } from "node:events";
+/**
+ * TaskRunner — manages background execution of CLI commands.
+ *
+ * Emits events:
+ *   "task:started"   (task)
+ *   "task:completed"  (task)
+ *   "task:failed"     (task)
+ *
+ * The interactive REPL listens to these events and prints
+ * notifications between prompts.
+ */
+export class TaskRunner extends EventEmitter {
+    tasks = new Map();
+    nextId = 1;
+    maxConcurrent;
+    runningCount = 0;
+    queue = [];
+    constructor(maxConcurrent = 5) {
+        super();
+        this.maxConcurrent = maxConcurrent;
+    }
+    /**
+     * Submit a task for background execution.
+     * Returns the task ID immediately.
+     */
+    submit(rawText, intent, executor) {
+        const task = {
+            id: this.nextId++,
+            rawText,
+            intent,
+            status: "pending",
+            startedAt: new Date(),
+            acknowledged: false,
+        };
+        this.tasks.set(task.id, task);
+        if (this.runningCount < this.maxConcurrent) {
+            this.run(task, executor);
+        }
+        else {
+            this.queue.push({ task, executor });
+            this.emit("task:queued", task);
+        }
+        return task;
+    }
+    async run(task, executor) {
+        task.status = "running";
+        this.runningCount++;
+        this.emit("task:started", task);
+        try {
+            const result = await executor();
+            task.status = "completed";
+            task.result = result;
+            task.completedAt = new Date();
+            this.emit("task:completed", task);
+        }
+        catch (err) {
+            task.status = "failed";
+            task.error = err instanceof Error ? err.message : String(err);
+            task.completedAt = new Date();
+            this.emit("task:failed", task);
+        }
+        finally {
+            this.runningCount--;
+            this.drainQueue();
+        }
+    }
+    drainQueue() {
+        while (this.queue.length > 0 && this.runningCount < this.maxConcurrent) {
+            const next = this.queue.shift();
+            this.run(next.task, next.executor);
+        }
+    }
+    /** Cancel a pending or running task (best-effort). */
+    cancel(id) {
+        const task = this.tasks.get(id);
+        if (!task)
+            return false;
+        if (task.status === "pending") {
+            task.status = "cancelled";
+            task.completedAt = new Date();
+            this.queue = this.queue.filter((q) => q.task.id !== id);
+            return true;
+        }
+        // Running tasks can't truly be cancelled without AbortController,
+        // but we mark them so the user knows.
+        if (task.status === "running") {
+            task.status = "cancelled";
+            task.completedAt = new Date();
+            return true;
+        }
+        return false;
+    }
+    /** Get a task by ID. */
+    get(id) {
+        return this.tasks.get(id);
+    }
+    /** List all tasks, optionally filtered by status. */
+    list(filter) {
+        const all = Array.from(this.tasks.values());
+        return filter ? all.filter((t) => t.status === filter) : all;
+    }
+    /** Get tasks that completed since the user last checked. */
+    getUnacknowledged() {
+        return Array.from(this.tasks.values()).filter((t) => !t.acknowledged && (t.status === "completed" || t.status === "failed"));
+    }
+    /** Mark a task as seen by the user. */
+    acknowledge(id) {
+        const task = this.tasks.get(id);
+        if (task)
+            task.acknowledged = true;
+    }
+    /** Acknowledge all completed tasks. */
+    acknowledgeAll() {
+        for (const task of this.tasks.values()) {
+            if (task.status === "completed" || task.status === "failed") {
+                task.acknowledged = true;
+            }
+        }
+    }
+    /** Clear completed/failed/cancelled tasks from the list. */
+    prune() {
+        let pruned = 0;
+        for (const [id, task] of this.tasks.entries()) {
+            if (task.status === "completed" || task.status === "failed" || task.status === "cancelled") {
+                this.tasks.delete(id);
+                pruned++;
+            }
+        }
+        return pruned;
+    }
+    /** How many tasks are currently running? */
+    get active() {
+        return this.runningCount;
+    }
+    /** How many tasks are in the queue? */
+    get queued() {
+        return this.queue.length;
+    }
+}
+/** Singleton instance used by the interactive CLI. */
+export const taskRunner = new TaskRunner();

package/dist/context/history.d.ts

@@ -0,0 +1,36 @@
+export interface HistoryEntry {
+    timestamp: string;
+    rawText: string;
+    intent: string;
+    fields: Record<string, unknown>;
+    command: string;
+    environment: string;
+    success: boolean;
+}
+export interface SessionContext {
+    sessionId: string;
+    startedAt: string;
+    lastActivity: string;
+    recentIntents: string[];
+    recentEnvironments: string[];
+    recentServices: string[];
+    variables: Record<string, unknown>;
+}
+export declare function recordHistory(entry: HistoryEntry): void;
+export declare function loadHistory(): HistoryEntry[];
+export declare function getRecentHistory(count?: number): HistoryEntry[];
+export declare function searchHistory(query: string): HistoryEntry[];
+export declare function clearHistory(): void;
+export declare function getSession(): SessionContext;
+export declare function setVariable(key: string, value: unknown): void;
+export declare function getVariable(key: string): unknown;
+/**
+ * Get context hints for the parser.
+ *
+ * Returns the most likely environment and service based on recent activity,
+ * so the parser can use these as smart defaults.
+ */
+export declare function getContextHints(): {
+    environment?: string;
+    service?: string;
+};

package/dist/context/history.js

@@ -0,0 +1,115 @@
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { resolve } from "node:path";
+import { DATA_DIR } from "../utils/paths.js";
+const HISTORY_FILE = resolve(DATA_DIR, "history.json");
+const SESSION_FILE = resolve(DATA_DIR, "session.json");
+const MAX_HISTORY = 500;
+function ensureDataDir() {
+    if (!existsSync(DATA_DIR)) {
+        mkdirSync(DATA_DIR, { recursive: true });
+    }
+}
+// ─── History ─────────────────────────────────────────────────────────────────
+export function recordHistory(entry) {
+    ensureDataDir();
+    const history = loadHistory();
+    history.push(entry);
+    // Trim to max
+    if (history.length > MAX_HISTORY) {
+        history.splice(0, history.length - MAX_HISTORY);
+    }
+    writeFileSync(HISTORY_FILE, JSON.stringify(history, null, 2));
+    // Also update session
+    updateSession(entry);
+}
+export function loadHistory() {
+    if (!existsSync(HISTORY_FILE))
+        return [];
+    const raw = readFileSync(HISTORY_FILE, "utf-8");
+    return JSON.parse(raw);
+}
+export function getRecentHistory(count = 10) {
+    const history = loadHistory();
+    return history.slice(-count);
+}
+export function searchHistory(query) {
+    const history = loadHistory();
+    const lower = query.toLowerCase();
+    return history.filter((h) => h.rawText.toLowerCase().includes(lower) ||
+        h.intent.includes(lower) ||
+        h.command.toLowerCase().includes(lower));
+}
+export function clearHistory() {
+    ensureDataDir();
+    writeFileSync(HISTORY_FILE, "[]");
+}
+// ─── Session Context ─────────────────────────────────────────────────────────
+function generateSessionId() {
+    return `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+}
+export function getSession() {
+    ensureDataDir();
+    if (existsSync(SESSION_FILE)) {
+        const raw = readFileSync(SESSION_FILE, "utf-8");
+        const session = JSON.parse(raw);
+        // If session is older than 1 hour, start new
+        const age = Date.now() - new Date(session.lastActivity).getTime();
+        if (age < 3600_000)
+            return session;
+    }
+    const session = {
+        sessionId: generateSessionId(),
+        startedAt: new Date().toISOString(),
+        lastActivity: new Date().toISOString(),
+        recentIntents: [],
+        recentEnvironments: [],
+        recentServices: [],
+        variables: {},
+    };
+    writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+    return session;
+}
+function updateSession(entry) {
+    const session = getSession();
+    session.lastActivity = new Date().toISOString();
+    // Track recent intents (last 10)
+    session.recentIntents.push(entry.intent);
+    if (session.recentIntents.length > 10)
+        session.recentIntents.shift();
+    // Track recent environments
+    if (entry.environment && !session.recentEnvironments.includes(entry.environment)) {
+        session.recentEnvironments.push(entry.environment);
+        if (session.recentEnvironments.length > 5)
+            session.recentEnvironments.shift();
+    }
+    // Track recent services
+    const service = entry.fields.service;
+    if (service && !session.recentServices.includes(service)) {
+        session.recentServices.push(service);
+        if (session.recentServices.length > 5)
+            session.recentServices.shift();
+    }
+    writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+}
+export function setVariable(key, value) {
+    const session = getSession();
+    session.variables[key] = value;
+    writeFileSync(SESSION_FILE, JSON.stringify(session, null, 2));
+}
+export function getVariable(key) {
+    const session = getSession();
+    return session.variables[key];
+}
+/**
+ * Get context hints for the parser.
+ *
+ * Returns the most likely environment and service based on recent activity,
+ * so the parser can use these as smart defaults.
+ */
+export function getContextHints() {
+    const session = getSession();
+    return {
+        environment: session.recentEnvironments[session.recentEnvironments.length - 1],
+        service: session.recentServices[session.recentServices.length - 1],
+    };
+}

package/dist/conversation/coreference.d.ts

@@ -0,0 +1,27 @@
+import type { Conversation } from "./store.js";
+import type { DynamicIntent } from "../types/intent.js";
+export interface CoreferenceResult {
+    /** The resolved text after pronoun replacement */
+    resolvedText: string;
+    /** Whether this is a repeat/reference to a previous command */
+    isReference: boolean;
+    /** The intent to use (from previous turn if reference) */
+    resolvedIntent?: DynamicIntent;
+    /** What was resolved and how */
+    resolutions: Array<{
+        original: string;
+        resolved: string;
+        source: "last_turn" | "knowledge_tree" | "pronoun";
+    }>;
+}
+/**
+ * Resolve coreferences in user input using conversation history.
+ */
+export declare function resolveCoreferences(rawText: string, conv: Conversation): CoreferenceResult;
+/**
+ * Extract entities from parsed fields for conversation tracking.
+ */
+export declare function extractEntitiesFromFields(fields: Record<string, unknown>): Array<{
+    text: string;
+    type: "service" | "environment" | "path" | "user" | "branch" | "container" | "unknown";
+}>;

package/dist/conversation/coreference.js

@@ -0,0 +1,147 @@
+import { getLastEntity, getRecentTurns } from "./store.js";
+/**
+ * Coreference resolver.
+ *
+ * Resolves pronouns and references like:
+ *   "do it again"          → repeat last command
+ *   "same but on prod"     → last command with environment changed
+ *   "that service"         → most recent service entity
+ *   "it"                   → most recent object/service
+ *   "do that on staging"   → last intent with env=staging
+ *   "restart it"           → restart + most recent service
+ *   "check the same one"   → most recent service/target
+ */
+// Patterns that signal a reference to a previous turn
+const REPEAT_PATTERNS = [
+    /^(do it|do that|run it|run that|same thing|again|repeat|redo|re-?run)\b/i,
+    /^same\b/i,
+];
+const PRONOUN_PATTERNS = [
+    { pattern: /\bit\b/i, refType: "any" },
+    { pattern: /\bthat service\b/i, refType: "service" },
+    { pattern: /\bthat server\b/i, refType: "service" },
+    { pattern: /\bthe same (one|service|server|thing)\b/i, refType: "service" },
+    { pattern: /\bthat (file|path|directory)\b/i, refType: "path" },
+    { pattern: /\bthere\b/i, refType: "environment" },
+    { pattern: /\bthat (env|environment|box|machine)\b/i, refType: "environment" },
+];
+const OVERRIDE_PATTERNS = [
+    { pattern: /\bbut (?:on|in) (\w+)\b/i, field: "environment" },
+    { pattern: /\binstead (?:on|in) (\w+)\b/i, field: "environment" },
+    { pattern: /\bon (\w+) instead\b/i, field: "environment" },
+    { pattern: /\bbut (?:for|with) (\w+)\b/i, field: "service" },
+    { pattern: /\binstead (?:of )?(\w+)\b/i, field: "service" },
+];
+/**
+ * Resolve coreferences in user input using conversation history.
+ */
+export function resolveCoreferences(rawText, conv) {
+    const resolutions = [];
+    let resolvedText = rawText;
+    let isReference = false;
+    let resolvedIntent;
+    const recentTurns = getRecentTurns(conv, 5);
+    const lastUserTurn = recentTurns[recentTurns.length - 1];
+    // 1. Check for full repeat patterns ("do it again", "same thing")
+    for (const pattern of REPEAT_PATTERNS) {
+        if (pattern.test(rawText.trim())) {
+            isReference = true;
+            if (lastUserTurn?.intent && lastUserTurn.fields) {
+                // Check for override modifiers ("same but on prod")
+                const overrides = extractOverrides(rawText);
+                const fields = { ...lastUserTurn.fields, ...overrides };
+                resolvedIntent = {
+                    intent: lastUserTurn.intent,
+                    confidence: 0.85,
+                    rawText,
+                    fields,
+                };
+                resolvedText = lastUserTurn.rawText;
+                resolutions.push({
+                    original: rawText,
+                    resolved: lastUserTurn.rawText,
+                    source: "last_turn",
+                });
+                for (const [key, value] of Object.entries(overrides)) {
+                    resolutions.push({
+                        original: `override: ${key}`,
+                        resolved: String(value),
+                        source: "last_turn",
+                    });
+                }
+            }
+            return { resolvedText, isReference, resolvedIntent, resolutions };
+        }
+    }
+    // 2. Resolve pronouns ("restart it", "check that service")
+    for (const { pattern, refType } of PRONOUN_PATTERNS) {
+        const match = rawText.match(pattern);
+        if (!match)
+            continue;
+        let resolved;
+        if (refType === "any") {
+            // "it" → most recent service, then most recent entity
+            resolved = getLastEntity(conv, "service")
+                ?? getLastEntity(conv, "path")
+                ?? getLastEntity(conv, "container");
+        }
+        else {
+            resolved = getLastEntity(conv, refType);
+        }
+        if (resolved) {
+            resolvedText = resolvedText.replace(match[0], resolved.entity);
+            resolutions.push({
+                original: match[0],
+                resolved: resolved.entity,
+                source: "knowledge_tree",
+            });
+        }
+    }
+    // 3. Check for override modifiers in non-repeat contexts
+    // "restart nginx but on staging" → already has "restart nginx", just override env
+    const overrides = extractOverrides(rawText);
+    if (Object.keys(overrides).length > 0) {
+        // Clean the override phrases from the text
+        for (const { pattern } of OVERRIDE_PATTERNS) {
+            resolvedText = resolvedText.replace(pattern, "").trim();
+        }
+    }
+    return { resolvedText, isReference, resolvedIntent, resolutions };
+}
+/**
+ * Extract field overrides from phrases like "but on prod", "instead on staging".
+ */
+function extractOverrides(text) {
+    const overrides = {};
+    for (const { pattern, field } of OVERRIDE_PATTERNS) {
+        const match = text.match(pattern);
+        if (match?.[1]) {
+            overrides[field] = match[1];
+        }
+    }
+    return overrides;
+}
+/**
+ * Extract entities from parsed fields for conversation tracking.
+ */
+export function extractEntitiesFromFields(fields) {
+    const entities = [];
+    const typeMap = {
+        service: "service",
+        environment: "environment",
+        path: "path",
+        source: "path",
+        destination: "path",
+        target: "path",
+        username: "user",
+        branch: "branch",
+        container: "container",
+    };
+    for (const [key, value] of Object.entries(fields)) {
+        if (value && typeof value === "string" && value.length > 0) {
+            const type = typeMap[key] ?? "unknown";
+            entities.push({ text: value, type });
+        }
+    }
+    return entities;
+}