icopilot 2.2.0

package/dist/session/session.js

@@ -0,0 +1,296 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { config } from '../config.js';
+import { GitContextProvider } from '../context/git-context.js';
+import { hookManager } from '../hooks/lifecycle.js';
+import { countTokensSync } from '../util/tokens.js';
+export class Session {
+    state;
+    file;
+    constructor(init) {
+        const id = init?.id || randomUUID();
+        this.state = {
+            id,
+            createdAt: init?.createdAt || new Date().toISOString(),
+            model: init?.model || config.defaultModel,
+            mode: init?.mode || 'ask',
+            cwd: init?.cwd || config.cwd,
+            messages: init?.messages || [],
+            todos: Array.isArray(init?.todos) ? [...init.todos] : [],
+            autopilotEnabled: Boolean(init?.autopilotEnabled),
+            systemPrompt: typeof init?.systemPrompt === 'string' ? init.systemPrompt : undefined,
+            pinned: normalizePinnedFiles(init?.pinned),
+            gitContext: normalizeGitContext(init?.gitContext),
+            changeTracking: normalizeChangeTracking(init?.changeTracking),
+        };
+        fs.mkdirSync(config.sessionDir, { recursive: true });
+        this.file = path.join(config.sessionDir, `${id}.json`);
+    }
+    static list() {
+        try {
+            if (!fs.existsSync(config.sessionDir))
+                return [];
+            return fs
+                .readdirSync(config.sessionDir)
+                .filter((name) => name.endsWith('.json'))
+                .map((name) => {
+                const file = path.join(config.sessionDir, name);
+                const stat = fs.statSync(file);
+                let state = {};
+                try {
+                    state = JSON.parse(fs.readFileSync(file, 'utf8'));
+                }
+                catch {
+                    /* keep best-effort listing */
+                }
+                const id = String(state.id || path.basename(name, '.json'));
+                return {
+                    id,
+                    file,
+                    createdAt: String(state.createdAt || stat.birthtime.toISOString()),
+                    mtime: stat.mtime,
+                    model: String(state.model || config.defaultModel),
+                    messageCount: Array.isArray(state.messages) ? state.messages.length : 0,
+                };
+            })
+                .sort((a, b) => b.mtime.getTime() - a.mtime.getTime());
+        }
+        catch {
+            return [];
+        }
+    }
+    static load(id) {
+        const safeId = path.basename(id, '.json');
+        const file = path.join(config.sessionDir, `${safeId}.json`);
+        const state = JSON.parse(fs.readFileSync(file, 'utf8'));
+        return new Session(state);
+    }
+    push(msg) {
+        this.state.messages.push(msg);
+        this.persist();
+    }
+    reset() {
+        this.state.messages = [];
+        this.persist();
+    }
+    setModel(m) {
+        this.state.model = m;
+        this.persist();
+    }
+    setMode(m) {
+        this.state.mode = m;
+        this.persist();
+    }
+    setCwd(p) {
+        const previousCwd = this.state.cwd;
+        this.state.cwd = p;
+        config.cwd = p;
+        this.persist();
+        if (previousCwd !== p) {
+            void hookManager.loadHooks(p).then(() => hookManager.emit('cwdChanged', {
+                sessionId: this.state.id,
+                previousCwd,
+                newCwd: p,
+                source: 'session',
+            }));
+        }
+    }
+    setAutopilotEnabled(enabled) {
+        this.state.autopilotEnabled = enabled;
+        this.persist();
+    }
+    setSystemPrompt(prompt) {
+        this.state.systemPrompt = prompt?.trim() ? prompt : undefined;
+        this.persist();
+    }
+    setTodos(todos) {
+        this.state.todos = todos.map((todo) => ({ ...todo }));
+        this.persist();
+    }
+    setPinned(files) {
+        this.state.pinned = files.map((file) => ({ ...file }));
+        this.persist();
+    }
+    setGitContext(files) {
+        this.state.gitContext = files.map((file) => ({ ...file }));
+        this.persist();
+    }
+    async initializeGitContext(provider = new GitContextProvider(this.state.cwd)) {
+        const files = await provider.getSessionContextFiles().catch(() => []);
+        this.state.gitContext = files.map((file) => ({ ...file }));
+        this.persist();
+        return this.state.gitContext;
+    }
+    persist() {
+        try {
+            fs.writeFileSync(this.file, JSON.stringify(this.state, null, 2), 'utf8');
+        }
+        catch {
+            /* ignore persistence errors */
+        }
+    }
+    /** Total token usage estimate over current message history. */
+    tokenUsage() {
+        let total = 0;
+        for (const m of this.state.messages) {
+            const c = typeof m.content === 'string'
+                ? m.content
+                : Array.isArray(m.content)
+                    ? m.content.map((p) => (typeof p?.text === 'string' ? p.text : '')).join('\n')
+                    : '';
+            if (c) {
+                try {
+                    total += countTokensSync(c);
+                }
+                catch {
+                    total += Math.ceil(c.length / 4);
+                }
+            }
+        }
+        return total;
+    }
+    toJSON() {
+        return JSON.stringify(this.state, null, 2);
+    }
+    toMarkdown() {
+        const lines = [
+            `# iCopilot session ${this.state.id}`,
+            '',
+            `- Created: ${this.state.createdAt}`,
+            `- Model: ${this.state.model}`,
+            `- CWD: ${this.state.cwd}`,
+            `- Messages: ${this.state.messages.length}`,
+            '',
+        ];
+        for (const message of this.state.messages) {
+            const role = String(message.role || 'message');
+            const name = role === 'tool'
+                ? ` ${message.tool_call_id || ''}`.trimEnd()
+                : message.name
+                    ? ` ${message.name}`
+                    : '';
+            lines.push(`## ${role}${name}`, '');
+            const content = contentToText(message.content);
+            if (content.trim())
+                lines.push(content.trim());
+            const toolCalls = message.tool_calls;
+            if (Array.isArray(toolCalls) && toolCalls.length) {
+                lines.push('', '```json');
+                lines.push(JSON.stringify(toolCalls, null, 2));
+                lines.push('```');
+            }
+            lines.push('');
+        }
+        return lines.join('\n').trimEnd() + '\n';
+    }
+    shouldAutoSummarize(threshold = 0.85) {
+        return this.tokenUsage() / config.contextWindow > threshold;
+    }
+    /** Replace history with a compacted summary message. */
+    compactInto(summary) {
+        this.state.messages = [
+            {
+                role: 'system',
+                content: `Conversation summary (auto-compacted to save tokens):\n\n${summary}`,
+            },
+        ];
+        this.persist();
+    }
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part?.text === 'string')
+                return part.text;
+            if (typeof part?.type === 'string')
+                return JSON.stringify(part);
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (content == null)
+        return '';
+    return JSON.stringify(content, null, 2);
+}
+function normalizePinnedFiles(data) {
+    if (!Array.isArray(data))
+        return [];
+    return data.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const candidate = entry;
+        if (typeof candidate.path !== 'string' ||
+            typeof candidate.addedAt !== 'string' ||
+            typeof candidate.tokens !== 'number') {
+            return [];
+        }
+        return [
+            {
+                path: candidate.path,
+                addedAt: candidate.addedAt,
+                tokens: candidate.tokens,
+            },
+        ];
+    });
+}
+function normalizeGitContext(data) {
+    if (!Array.isArray(data))
+        return [];
+    return data.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const candidate = entry;
+        if (typeof candidate.path !== 'string')
+            return [];
+        if (candidate.status !== 'added' &&
+            candidate.status !== 'modified' &&
+            candidate.status !== 'deleted') {
+            return [];
+        }
+        return [
+            {
+                path: candidate.path,
+                status: candidate.status,
+                diff: typeof candidate.diff === 'string' ? candidate.diff : undefined,
+            },
+        ];
+    });
+}
+function normalizeChangeTracking(data) {
+    if (!data || typeof data !== 'object')
+        return undefined;
+    const candidate = data;
+    if (typeof candidate.sessionStartRef !== 'string' ||
+        typeof candidate.sessionStartAt !== 'string' ||
+        !Array.isArray(candidate.turnSnapshots)) {
+        return undefined;
+    }
+    const turnSnapshots = candidate.turnSnapshots.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const snapshot = entry;
+        if (typeof snapshot.turnIndex !== 'number' ||
+            !Number.isInteger(snapshot.turnIndex) ||
+            typeof snapshot.ref !== 'string' ||
+            typeof snapshot.createdAt !== 'string') {
+            return [];
+        }
+        return [
+            {
+                turnIndex: snapshot.turnIndex,
+                ref: snapshot.ref,
+                createdAt: snapshot.createdAt,
+            },
+        ];
+    });
+    return {
+        sessionStartRef: candidate.sessionStartRef,
+        sessionStartAt: candidate.sessionStartAt,
+        turnSnapshots,
+    };
+}

package/dist/session/share.js

@@ -0,0 +1,313 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { Session } from './session.js';
+import { theme } from '../ui/theme.js';
+const SHARE_VERSION = 1;
+const DEFAULT_TITLE_PREFIX = 'Shared session';
+export function exportSessionBundle(session) {
+    const bundle = {
+        version: SHARE_VERSION,
+        id: session.state.id,
+        title: deriveTitle(session.state),
+        model: session.state.model,
+        messages: clone(session.state.messages),
+        metadata: {
+            cwd: session.state.cwd,
+            tokensUsed: session.tokenUsage(),
+            messageCount: session.state.messages.length,
+            createdAt: session.state.createdAt,
+            duration: formatDuration(session.state.createdAt),
+        },
+        exportedAt: new Date().toISOString(),
+        mode: session.state.mode,
+        todos: cloneTodos(session.state.todos),
+        pinned: clonePinned(session.state.pinned),
+    };
+    return bundle;
+}
+export function importSessionBundle(data) {
+    try {
+        const parsed = typeof data === 'string' ? JSON.parse(data) : data;
+        const bundle = validateBundle(parsed);
+        const session = new Session({
+            createdAt: bundle.metadata.createdAt,
+            model: bundle.model,
+            mode: bundle.mode === 'plan' ? 'plan' : 'ask',
+            cwd: bundle.metadata.cwd,
+            messages: clone(bundle.messages),
+            todos: cloneTodos(bundle.todos),
+            pinned: clonePinned(bundle.pinned),
+        });
+        session.persist();
+        return { success: true, sessionId: session.state.id };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Invalid session bundle.';
+        return { success: false, error: message };
+    }
+}
+export function sessionToMarkdown(session) {
+    const bundle = exportSessionBundle(session);
+    const lines = [
+        `# ${bundle.title}`,
+        '',
+        '## Metadata',
+        '',
+        `- Session ID: ${bundle.id}`,
+        `- Exported: ${bundle.exportedAt}`,
+        `- Created: ${bundle.metadata.createdAt}`,
+        `- Duration: ${bundle.metadata.duration}`,
+        `- Model: ${bundle.model}`,
+        `- Working directory: ${bundle.metadata.cwd}`,
+        `- Tokens used: ${bundle.metadata.tokensUsed}`,
+        `- Message count: ${bundle.metadata.messageCount}`,
+        '',
+        '## Conversation',
+        '',
+    ];
+    bundle.messages.forEach((message, index) => {
+        const role = typeof message?.role === 'string' ? message.role : 'message';
+        const suffix = role === 'tool'
+            ? ` ${typeof message?.tool_call_id === 'string' ? message.tool_call_id : ''}`.trimEnd()
+            : typeof message?.name === 'string'
+                ? ` ${message.name}`
+                : '';
+        lines.push(`### ${index + 1}. ${role}${suffix}`, '');
+        const content = contentToText(message?.content).trim();
+        lines.push(content || '_[no content]_');
+        if (Array.isArray(message?.tool_calls) && message.tool_calls.length) {
+            lines.push('', '#### Tool calls', '', '```json', JSON.stringify(message.tool_calls, null, 2), '```');
+        }
+        lines.push('');
+    });
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export function sessionToClipboard(session) {
+    const bundle = exportSessionBundle(session);
+    const lines = [
+        `[iCopilot] ${bundle.title}`,
+        `session=${bundle.id} model=${bundle.model} messages=${bundle.metadata.messageCount} tokens=${bundle.metadata.tokensUsed}`,
+    ];
+    bundle.messages.forEach((message, index) => {
+        const role = typeof message?.role === 'string' ? message.role : 'message';
+        const text = truncate(singleLine(contentToText(message?.content)), 220) || '[no content]';
+        lines.push(`${index + 1}. ${role}: ${text}`);
+        if (Array.isArray(message?.tool_calls) && message.tool_calls.length) {
+            const toolNames = message.tool_calls
+                .map((call) => {
+                if (typeof call?.function?.name === 'string')
+                    return call.function.name;
+                if (typeof call?.id === 'string')
+                    return call.id;
+                return 'tool-call';
+            })
+                .join(', ');
+            lines.push(`   tools: ${toolNames}`);
+        }
+    });
+    return `${lines.join('\n')}\n`;
+}
+export function shareCommand(args, session) {
+    const [subcommand = '', ...rest] = args;
+    const action = subcommand.toLowerCase();
+    if (!action)
+        return shareUsage();
+    if (action === 'export') {
+        const requestedPath = rest.join(' ').trim();
+        const target = path.resolve(session.state.cwd, requestedPath || `session-${session.state.id}.json`);
+        fs.mkdirSync(path.dirname(target), { recursive: true });
+        fs.writeFileSync(target, `${JSON.stringify(exportSessionBundle(session), null, 2)}\n`, 'utf8');
+        return `${theme.ok('✔ exported shared session')} ${target}\n`;
+    }
+    if (action === 'import') {
+        const requestedPath = rest.join(' ').trim();
+        if (!requestedPath)
+            return shareUsage();
+        const target = path.resolve(session.state.cwd, requestedPath);
+        if (!fs.existsSync(target) || !fs.statSync(target).isFile()) {
+            return `${theme.err(`file not found: ${target}`)}\n`;
+        }
+        const result = importSessionBundle(fs.readFileSync(target, 'utf8'));
+        if (!result.success) {
+            return `${theme.err(`import failed: ${result.error || 'unknown error'}`)}\n`;
+        }
+        return `${theme.ok(`✔ imported session as ${result.sessionId}`)}\n`;
+    }
+    if (action === 'clipboard') {
+        return sessionToClipboard(session);
+    }
+    return shareUsage();
+}
+function shareUsage() {
+    return [
+        'usage: /share export [path]',
+        '       /share import <path>',
+        '       /share clipboard',
+        '',
+    ].join('\n');
+}
+function validateBundle(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Session bundle must be a JSON object.');
+    }
+    const bundle = input;
+    if (typeof bundle.version !== 'number' || bundle.version < 1) {
+        throw new Error('Session bundle version is invalid.');
+    }
+    if (typeof bundle.id !== 'string' || !bundle.id.trim()) {
+        throw new Error('Session bundle id is missing.');
+    }
+    if (typeof bundle.title !== 'string' || !bundle.title.trim()) {
+        throw new Error('Session bundle title is missing.');
+    }
+    if (typeof bundle.model !== 'string' || !bundle.model.trim()) {
+        throw new Error('Session bundle model is missing.');
+    }
+    if (!Array.isArray(bundle.messages)) {
+        throw new Error('Session bundle messages must be an array.');
+    }
+    if (typeof bundle.exportedAt !== 'string' || !bundle.exportedAt.trim()) {
+        throw new Error('Session bundle export timestamp is missing.');
+    }
+    const metadata = validateMetadata(bundle.metadata);
+    const mode = bundle.mode === 'plan' ? 'plan' : 'ask';
+    return {
+        version: bundle.version,
+        id: bundle.id,
+        title: bundle.title,
+        model: bundle.model,
+        messages: clone(bundle.messages),
+        metadata,
+        exportedAt: bundle.exportedAt,
+        mode,
+        todos: cloneTodos(bundle.todos),
+        pinned: clonePinned(bundle.pinned),
+    };
+}
+function validateMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
+        throw new Error('Session bundle metadata is missing.');
+    }
+    const candidate = metadata;
+    if (typeof candidate.cwd !== 'string' || !candidate.cwd.trim()) {
+        throw new Error('Session bundle cwd is missing.');
+    }
+    if (typeof candidate.tokensUsed !== 'number' || Number.isNaN(candidate.tokensUsed)) {
+        throw new Error('Session bundle tokensUsed is invalid.');
+    }
+    if (typeof candidate.messageCount !== 'number' || Number.isNaN(candidate.messageCount)) {
+        throw new Error('Session bundle messageCount is invalid.');
+    }
+    if (typeof candidate.createdAt !== 'string' || !candidate.createdAt.trim()) {
+        throw new Error('Session bundle createdAt is missing.');
+    }
+    if (typeof candidate.duration !== 'string' || !candidate.duration.trim()) {
+        throw new Error('Session bundle duration is missing.');
+    }
+    return {
+        cwd: candidate.cwd,
+        tokensUsed: candidate.tokensUsed,
+        messageCount: candidate.messageCount,
+        createdAt: candidate.createdAt,
+        duration: candidate.duration,
+    };
+}
+function deriveTitle(state) {
+    for (const message of state.messages) {
+        const text = singleLine(contentToText(message?.content));
+        if (text)
+            return truncate(text, 72);
+    }
+    return `${DEFAULT_TITLE_PREFIX} ${state.id.slice(0, 8)}`;
+}
+function formatDuration(createdAt) {
+    const created = new Date(createdAt).getTime();
+    if (Number.isNaN(created))
+        return 'unknown';
+    const totalSeconds = Math.max(0, Math.floor((Date.now() - created) / 1000));
+    const hours = Math.floor(totalSeconds / 3600);
+    const minutes = Math.floor((totalSeconds % 3600) / 60);
+    const seconds = totalSeconds % 60;
+    if (hours > 0)
+        return `${hours}h ${minutes}m`;
+    if (minutes > 0)
+        return `${minutes}m ${seconds}s`;
+    return `${seconds}s`;
+}
+function contentToText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part?.text === 'string')
+                return part.text;
+            if (typeof part?.type === 'string')
+                return JSON.stringify(part);
+            return '';
+        })
+            .filter(Boolean)
+            .join('\n');
+    }
+    if (content == null)
+        return '';
+    return JSON.stringify(content, null, 2);
+}
+function clone(value) {
+    return JSON.parse(JSON.stringify(value));
+}
+function cloneTodos(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const candidate = item;
+        if (typeof candidate.id !== 'string' ||
+            typeof candidate.text !== 'string' ||
+            typeof candidate.done !== 'boolean' ||
+            typeof candidate.createdAt !== 'string') {
+            return [];
+        }
+        return [
+            {
+                id: candidate.id,
+                text: candidate.text,
+                done: candidate.done,
+                createdAt: candidate.createdAt,
+                ...(typeof candidate.completedAt === 'string'
+                    ? { completedAt: candidate.completedAt }
+                    : {}),
+            },
+        ];
+    });
+}
+function clonePinned(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const candidate = item;
+        if (typeof candidate.path !== 'string' ||
+            typeof candidate.addedAt !== 'string' ||
+            typeof candidate.tokens !== 'number') {
+            return [];
+        }
+        return [
+            {
+                path: candidate.path,
+                addedAt: candidate.addedAt,
+                tokens: candidate.tokens,
+            },
+        ];
+    });
+}
+function singleLine(value) {
+    return value.replace(/\s+/g, ' ').trim();
+}
+function truncate(value, maxLength) {
+    if (value.length <= maxLength)
+        return value;
+    return `${value.slice(0, Math.max(0, maxLength - 1)).trimEnd()}…`;
+}

package/dist/session/undo-journal.js

@@ -0,0 +1,91 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { config } from '../config.js';
+const STACK_LIMIT = 50;
+const JOURNAL_FILE = 'undo-journal.json';
+function journalPath() {
+    return path.join(config.sessionDir, JOURNAL_FILE);
+}
+function emptyState() {
+    return { undo: [], redo: [] };
+}
+function ensureSessionDir() {
+    fs.mkdirSync(config.sessionDir, { recursive: true });
+}
+function loadJournal() {
+    ensureSessionDir();
+    try {
+        const raw = fs.readFileSync(journalPath(), 'utf8');
+        const parsed = JSON.parse(raw);
+        return {
+            undo: Array.isArray(parsed.undo) ? parsed.undo : [],
+            redo: Array.isArray(parsed.redo) ? parsed.redo : [],
+        };
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return emptyState();
+        return emptyState();
+    }
+}
+function capStack(stack) {
+    return stack.slice(Math.max(0, stack.length - STACK_LIMIT));
+}
+function saveJournal(state) {
+    ensureSessionDir();
+    const capped = { undo: capStack(state.undo), redo: capStack(state.redo) };
+    fs.writeFileSync(journalPath(), `${JSON.stringify(capped, null, 2)}\n`, 'utf8');
+}
+function restorePath(absPath, bytes) {
+    if (bytes === null) {
+        fs.rmSync(absPath, { force: true });
+        return;
+    }
+    fs.mkdirSync(path.dirname(absPath), { recursive: true });
+    fs.writeFileSync(absPath, bytes);
+}
+export function recordWrite(absPath, prevBytes, nextBytes) {
+    const state = loadJournal();
+    const entry = {
+        id: crypto.randomUUID(),
+        ts: Date.now(),
+        path: path.resolve(absPath),
+        prevBytes,
+        nextBytes,
+    };
+    state.undo.push(entry);
+    state.undo = capStack(state.undo);
+    state.redo = [];
+    saveJournal(state);
+    return entry;
+}
+export function undoLast() {
+    const state = loadJournal();
+    const entry = state.undo.pop();
+    if (!entry)
+        return null;
+    restorePath(entry.path, entry.prevBytes);
+    state.redo.push(entry);
+    state.redo = capStack(state.redo);
+    saveJournal(state);
+    return { entry, restored: 'prev' };
+}
+export function redoLast() {
+    const state = loadJournal();
+    const entry = state.redo.shift();
+    if (!entry)
+        return null;
+    restorePath(entry.path, entry.nextBytes);
+    state.undo.push(entry);
+    state.undo = capStack(state.undo);
+    saveJournal(state);
+    return { entry, restored: 'next' };
+}
+export function journalSize() {
+    const state = loadJournal();
+    return { undo: state.undo.length, redo: state.redo.length };
+}
+export function clearJournal() {
+    saveJournal(emptyState());
+}