neuro-cli 4.1.0

package/dist/core/session.d.ts

@@ -0,0 +1,83 @@
+import { Session, Message, AgentExecution } from '../core/types.js';
+export declare class SessionManager {
+    private currentSession;
+    /**
+     * Create a new session
+     */
+    create(workingDirectory: string, model: string): Session;
+    /**
+     * Load an existing session
+     */
+    load(sessionId: string): Session | null;
+    /**
+     * Get the current session
+     */
+    getCurrent(): Session | null;
+    /**
+     * Save the current session
+     */
+    save(): void;
+    /**
+     * Add a message to the current session
+     */
+    addMessage(message: Message): void;
+    /**
+     * Add an agent execution record
+     */
+    addAgentExecution(execution: AgentExecution): void;
+    /**
+     * Update token usage
+     */
+    updateUsage(inputTokens: number, outputTokens: number, cost: number): void;
+    /**
+     * List all sessions
+     */
+    list(): Array<{
+        id: string;
+        createdAt: number;
+        messageCount: number;
+        model: string;
+        cost: number;
+    }>;
+    /**
+     * Delete a session
+     */
+    delete(sessionId: string): boolean;
+    /**
+     * Fork a session (create a copy with new ID)
+     */
+    fork(sessionId: string): Session | null;
+    /**
+     * Get the most recent session
+     */
+    getMostRecent(): Session | null;
+    /**
+     * Search sessions by content
+     */
+    search(query: string): Array<{
+        id: string;
+        createdAt: number;
+        messageCount: number;
+        model: string;
+        cost: number;
+        matchPreview: string;
+    }>;
+    /**
+     * Export a session to a portable JSON format
+     */
+    exportSession(sessionId: string, outputPath: string): boolean;
+    /**
+     * Import a session from a JSON file
+     */
+    importSession(filePath: string): Session | null;
+    /**
+     * Get session statistics
+     */
+    getStats(): {
+        totalSessions: number;
+        totalMessages: number;
+        totalCost: number;
+        totalTokens: number;
+    };
+}
+//# sourceMappingURL=session.d.ts.map

package/dist/core/session.js

@@ -0,0 +1,269 @@
+// ============================================================
+// NeuroCLI - Session Manager
+// Persistent conversation sessions
+// ============================================================
+import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+const SESSION_DIR = join(homedir(), '.neuro', 'sessions');
+export class SessionManager {
+    currentSession = null;
+    /**
+     * Create a new session
+     */
+    create(workingDirectory, model) {
+        this.currentSession = {
+            id: `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            messages: [],
+            workingDirectory,
+            model,
+            totalInputTokens: 0,
+            totalOutputTokens: 0,
+            totalCost: 0,
+            agentHistory: [],
+            tags: [],
+        };
+        this.save();
+        return this.currentSession;
+    }
+    /**
+     * Load an existing session
+     */
+    load(sessionId) {
+        const filePath = join(SESSION_DIR, `${sessionId}.json`);
+        if (!existsSync(filePath))
+            return null;
+        try {
+            const data = readFileSync(filePath, 'utf-8');
+            this.currentSession = JSON.parse(data);
+            return this.currentSession;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get the current session
+     */
+    getCurrent() {
+        return this.currentSession;
+    }
+    /**
+     * Save the current session
+     */
+    save() {
+        if (!this.currentSession)
+            return;
+        if (!existsSync(SESSION_DIR)) {
+            mkdirSync(SESSION_DIR, { recursive: true });
+        }
+        this.currentSession.updatedAt = Date.now();
+        const filePath = join(SESSION_DIR, `${this.currentSession.id}.json`);
+        writeFileSync(filePath, JSON.stringify(this.currentSession, null, 2), 'utf-8');
+    }
+    /**
+     * Add a message to the current session
+     */
+    addMessage(message) {
+        if (!this.currentSession)
+            return;
+        this.currentSession.messages.push(message);
+    }
+    /**
+     * Add an agent execution record
+     */
+    addAgentExecution(execution) {
+        if (!this.currentSession)
+            return;
+        this.currentSession.agentHistory.push(execution);
+    }
+    /**
+     * Update token usage
+     */
+    updateUsage(inputTokens, outputTokens, cost) {
+        if (!this.currentSession)
+            return;
+        this.currentSession.totalInputTokens += inputTokens;
+        this.currentSession.totalOutputTokens += outputTokens;
+        this.currentSession.totalCost += cost;
+    }
+    /**
+     * List all sessions
+     */
+    list() {
+        if (!existsSync(SESSION_DIR))
+            return [];
+        const sessions = [];
+        for (const file of readdirSync(SESSION_DIR)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(readFileSync(join(SESSION_DIR, file), 'utf-8'));
+                sessions.push({
+                    id: data.id,
+                    createdAt: data.createdAt,
+                    messageCount: data.messages?.length || 0,
+                    model: data.model,
+                    cost: data.totalCost || 0,
+                });
+            }
+            catch { }
+        }
+        return sessions.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Delete a session
+     */
+    delete(sessionId) {
+        const filePath = join(SESSION_DIR, `${sessionId}.json`);
+        if (!existsSync(filePath))
+            return false;
+        try {
+            unlinkSync(filePath);
+            if (this.currentSession?.id === sessionId) {
+                this.currentSession = null;
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Fork a session (create a copy with new ID)
+     */
+    fork(sessionId) {
+        const source = this.load(sessionId);
+        if (!source)
+            return null;
+        const forked = {
+            ...source,
+            id: `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            messages: [...source.messages],
+            agentHistory: [...source.agentHistory],
+            totalInputTokens: source.totalInputTokens,
+            totalOutputTokens: source.totalOutputTokens,
+            totalCost: source.totalCost,
+            forkedFrom: source.id,
+            parentSessionId: source.id,
+        };
+        this.currentSession = forked;
+        this.save();
+        return forked;
+    }
+    /**
+     * Get the most recent session
+     */
+    getMostRecent() {
+        const sessions = this.list();
+        if (sessions.length === 0)
+            return null;
+        return this.load(sessions[0].id);
+    }
+    /**
+     * Search sessions by content
+     */
+    search(query) {
+        if (!existsSync(SESSION_DIR))
+            return [];
+        const results = [];
+        const lowerQuery = query.toLowerCase();
+        for (const file of readdirSync(SESSION_DIR)) {
+            if (!file.endsWith('.json'))
+                continue;
+            try {
+                const data = JSON.parse(readFileSync(join(SESSION_DIR, file), 'utf-8'));
+                // Search in messages
+                const matchMsg = data.messages?.find((m) => m.content?.toLowerCase().includes(lowerQuery));
+                if (matchMsg) {
+                    const preview = matchMsg.content.slice(0, 80).replace(/\n/g, ' ');
+                    results.push({
+                        id: data.id,
+                        createdAt: data.createdAt,
+                        messageCount: data.messages?.length || 0,
+                        model: data.model,
+                        cost: data.totalCost || 0,
+                        matchPreview: preview,
+                    });
+                }
+            }
+            catch { }
+        }
+        return results.sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Export a session to a portable JSON format
+     */
+    exportSession(sessionId, outputPath) {
+        const session = this.load(sessionId);
+        if (!session)
+            return false;
+        const exportData = {
+            version: '3.0.0',
+            exportedAt: Date.now(),
+            session,
+            neuroVersion: '3.0.0',
+        };
+        try {
+            writeFileSync(outputPath, JSON.stringify(exportData, null, 2), 'utf-8');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Import a session from a JSON file
+     */
+    importSession(filePath) {
+        try {
+            const content = readFileSync(filePath, 'utf-8');
+            const importData = JSON.parse(content);
+            const sessionData = importData.session || importData;
+            const newSession = {
+                id: `session_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+                createdAt: Date.now(),
+                updatedAt: Date.now(),
+                messages: sessionData.messages || [],
+                workingDirectory: sessionData.workingDirectory || process.cwd(),
+                model: sessionData.model || 'qwen/qwen3-coder:free',
+                totalInputTokens: sessionData.totalInputTokens || 0,
+                totalOutputTokens: sessionData.totalOutputTokens || 0,
+                totalCost: sessionData.totalCost || 0,
+                agentHistory: sessionData.agentHistory || [],
+                tags: sessionData.tags || [],
+                description: sessionData.description || `Imported from ${filePath}`,
+                parentSessionId: sessionData.id,
+            };
+            this.currentSession = newSession;
+            this.save();
+            return newSession;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Get session statistics
+     */
+    getStats() {
+        const sessions = this.list();
+        let totalMessages = 0;
+        let totalCost = 0;
+        for (const session of sessions) {
+            totalMessages += session.messageCount;
+            totalCost += session.cost;
+        }
+        return {
+            totalSessions: sessions.length,
+            totalMessages,
+            totalCost,
+            totalTokens: 0, // Would need to sum from all sessions
+        };
+    }
+}
+//# sourceMappingURL=session.js.map

package/dist/core/shell-completion.d.ts

@@ -0,0 +1,51 @@
+export type ShellType = 'bash' | 'zsh' | 'fish';
+export interface CompletionOptions {
+    commands: Array<{
+        name: string;
+        description: string;
+        options: Array<{
+            flags: string;
+            description: string;
+        }>;
+        subcommands?: Array<{
+            name: string;
+            description: string;
+        }>;
+    }>;
+    models: string[];
+    themes: string[];
+    permissionModes: string[];
+    agents: string[];
+    slashCommands: string[];
+}
+export declare class ShellCompletionGenerator {
+    private options;
+    constructor(options: CompletionOptions);
+    /**
+     * Generate a completion script for the given shell type.
+     */
+    generate(shell: ShellType): string;
+    generateBash(): string;
+    generateZsh(): string;
+    generateFish(): string;
+    writeToFile(shell: ShellType, filePath: string): void;
+    static getDefaultOptions(): CompletionOptions;
+    /**
+     * Escape a string for safe embedding in a bash double-quoted context.
+     * Escapes: backslash, double-quote, dollar, backtick, and exclamation.
+     */
+    private bashEscape;
+    /**
+     * Escape a string for safe embedding in a zsh single-quoted context.
+     * Inside single quotes only the single quote itself needs escaping;
+     * zsh uses '\'' (end quote, escaped quote, reopen quote).
+     */
+    private zshEscape;
+    /**
+     * Escape a string for safe embedding in a fish completion description
+     * or argument. Fish uses single quotes; escape single quotes and
+     * backslashes.
+     */
+    private fishEscape;
+}
+//# sourceMappingURL=shell-completion.d.ts.map