icopilot 2.2.0

package/dist/session/handoff.js

@@ -0,0 +1,405 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { execSync } from 'node:child_process';
+import { PersistentMemory } from '../context/persistent-memory.js';
+import { Session } from './session.js';
+const HANDOFF_VERSION = 1;
+const DEFAULT_FILENAME = '.icopilot-handoff.json';
+export function createHandoff(session, opts = {}) {
+    const pinned = clonePinned(session.state.pinned);
+    const memory = loadPersistentMemory(session.state.cwd, opts.memoryStorePath);
+    const files = pinned.map((file) => snapshotPinnedFile(file));
+    const messages = limitMessages(session.state.messages, opts.maxMessages);
+    return {
+        version: HANDOFF_VERSION,
+        session: {
+            id: session.state.id,
+            createdAt: session.state.createdAt,
+            model: session.state.model,
+            mode: session.state.mode,
+            cwd: session.state.cwd,
+            messages: cloneMessages(messages),
+            todos: cloneTodos(session.state.todos),
+            autopilotEnabled: Boolean(session.state.autopilotEnabled),
+            systemPrompt: typeof session.state.systemPrompt === 'string' ? session.state.systemPrompt : undefined,
+            pinned,
+            gitContext: cloneGitContext(session.state.gitContext),
+        },
+        context: {
+            files,
+            pinned,
+            memory,
+        },
+        metadata: {
+            author: opts.author?.trim() || detectAuthor(),
+            timestamp: new Date().toISOString(),
+            branch: opts.branch?.trim() || detectBranch(session.state.cwd),
+            description: opts.description?.trim() || '',
+        },
+    };
+}
+export function receiveHandoff(bundle) {
+    const normalized = validateHandoffBundle(bundle);
+    const importedContext = buildImportedContextMessage(normalized);
+    const session = new Session({
+        createdAt: normalized.session.createdAt,
+        model: normalized.session.model,
+        mode: normalized.session.mode,
+        cwd: normalized.session.cwd,
+        messages: importedContext
+            ? [
+                { role: 'system', content: importedContext },
+                ...cloneMessages(normalized.session.messages),
+            ]
+            : cloneMessages(normalized.session.messages),
+        todos: cloneTodos(normalized.session.todos),
+        autopilotEnabled: Boolean(normalized.session.autopilotEnabled),
+        systemPrompt: typeof normalized.session.systemPrompt === 'string'
+            ? normalized.session.systemPrompt
+            : undefined,
+        pinned: clonePinned(normalized.context.pinned),
+        gitContext: cloneGitContext(normalized.session.gitContext),
+    });
+    restorePersistentMemory(session.state.cwd, normalized.context.memory);
+    session.persist();
+    return session;
+}
+export function exportHandoffFile(bundle, targetPath) {
+    const normalized = validateHandoffBundle(bundle);
+    const target = resolveHandoffPath(normalized.session.cwd, targetPath);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, `${JSON.stringify(normalized, null, 2)}\n`, 'utf8');
+    return target;
+}
+export function importHandoffFile(targetPath) {
+    const resolved = path.resolve(targetPath);
+    const parsed = JSON.parse(fs.readFileSync(resolved, 'utf8'));
+    return validateHandoffBundle(parsed);
+}
+export function previewHandoff(bundle) {
+    const normalized = validateHandoffBundle(bundle);
+    const previewFiles = normalized.context.files.map((file) => file.missing ? `${file.path} (missing snapshot)` : file.path);
+    const lines = [
+        'Handoff bundle',
+        `  version: ${normalized.version}`,
+        `  author: ${normalized.metadata.author}`,
+        `  timestamp: ${normalized.metadata.timestamp}`,
+        `  branch: ${normalized.metadata.branch || '(unknown)'}`,
+        `  description: ${normalized.metadata.description || '(none)'}`,
+        `  cwd: ${normalized.session.cwd}`,
+        `  model: ${normalized.session.model}`,
+        `  mode: ${normalized.session.mode}`,
+        `  messages: ${normalized.session.messages.length}`,
+        `  todos: ${normalized.session.todos.length}`,
+        `  pinned: ${normalized.context.pinned.length}`,
+        `  memory: ${normalized.context.memory.length}`,
+    ];
+    if (previewFiles.length) {
+        lines.push('  files:');
+        previewFiles.forEach((file) => lines.push(`    - ${file}`));
+    }
+    return `${lines.join('\n')}\n`;
+}
+function validateHandoffBundle(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Handoff bundle must be a JSON object.');
+    }
+    const bundle = input;
+    if (bundle.version !== HANDOFF_VERSION) {
+        throw new Error(`Unsupported handoff bundle version: ${typeof bundle.version === 'number' ? bundle.version : 'unknown'}.`);
+    }
+    return {
+        version: HANDOFF_VERSION,
+        session: validateSessionState(bundle.session),
+        context: validateContext(bundle.context),
+        metadata: validateMetadata(bundle.metadata),
+    };
+}
+function validateSessionState(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Handoff bundle session is missing.');
+    }
+    const session = input;
+    const mode = session.mode === 'plan' ? 'plan' : 'ask';
+    if (typeof session.id !== 'string' || !session.id.trim()) {
+        throw new Error('Handoff bundle session id is missing.');
+    }
+    if (typeof session.createdAt !== 'string' || !session.createdAt.trim()) {
+        throw new Error('Handoff bundle session createdAt is missing.');
+    }
+    if (typeof session.model !== 'string' || !session.model.trim()) {
+        throw new Error('Handoff bundle session model is missing.');
+    }
+    if (typeof session.cwd !== 'string' || !session.cwd.trim()) {
+        throw new Error('Handoff bundle session cwd is missing.');
+    }
+    if (!Array.isArray(session.messages)) {
+        throw new Error('Handoff bundle session messages must be an array.');
+    }
+    return {
+        id: session.id,
+        createdAt: session.createdAt,
+        model: session.model,
+        mode,
+        cwd: session.cwd,
+        messages: cloneMessages(session.messages),
+        todos: cloneTodos(session.todos),
+        autopilotEnabled: Boolean(session.autopilotEnabled),
+        systemPrompt: typeof session.systemPrompt === 'string' ? session.systemPrompt : undefined,
+        pinned: clonePinned(session.pinned),
+        gitContext: cloneGitContext(session.gitContext),
+    };
+}
+function validateContext(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Handoff bundle context is missing.');
+    }
+    const context = input;
+    if (!Array.isArray(context.files)) {
+        throw new Error('Handoff bundle context files must be an array.');
+    }
+    if (!Array.isArray(context.pinned)) {
+        throw new Error('Handoff bundle context pinned must be an array.');
+    }
+    if (!Array.isArray(context.memory)) {
+        throw new Error('Handoff bundle context memory must be an array.');
+    }
+    return {
+        files: context.files.flatMap((file) => {
+            if (!file || typeof file !== 'object')
+                return [];
+            const candidate = file;
+            if (typeof candidate.path !== 'string' || typeof candidate.content !== 'string')
+                return [];
+            return [
+                {
+                    path: candidate.path,
+                    content: candidate.content,
+                    addedAt: typeof candidate.addedAt === 'string' ? candidate.addedAt : undefined,
+                    tokens: typeof candidate.tokens === 'number' ? candidate.tokens : undefined,
+                    missing: Boolean(candidate.missing),
+                },
+            ];
+        }),
+        pinned: clonePinned(context.pinned),
+        memory: cloneMemoryEntries(context.memory),
+    };
+}
+function validateMetadata(input) {
+    if (!input || typeof input !== 'object' || Array.isArray(input)) {
+        throw new Error('Handoff bundle metadata is missing.');
+    }
+    const metadata = input;
+    if (typeof metadata.author !== 'string' || !metadata.author.trim()) {
+        throw new Error('Handoff bundle metadata author is missing.');
+    }
+    if (typeof metadata.timestamp !== 'string' || !metadata.timestamp.trim()) {
+        throw new Error('Handoff bundle metadata timestamp is missing.');
+    }
+    if (typeof metadata.branch !== 'string') {
+        throw new Error('Handoff bundle metadata branch is invalid.');
+    }
+    if (typeof metadata.description !== 'string') {
+        throw new Error('Handoff bundle metadata description is invalid.');
+    }
+    return {
+        author: metadata.author,
+        timestamp: metadata.timestamp,
+        branch: metadata.branch,
+        description: metadata.description,
+    };
+}
+function limitMessages(messages, maxMessages) {
+    if (typeof maxMessages !== 'number' || !Number.isFinite(maxMessages) || maxMessages <= 0) {
+        return cloneMessages(messages);
+    }
+    return cloneMessages(messages.slice(-Math.floor(maxMessages)));
+}
+function snapshotPinnedFile(file) {
+    try {
+        return {
+            path: file.path,
+            addedAt: file.addedAt,
+            tokens: file.tokens,
+            content: fs.readFileSync(file.path, 'utf8'),
+            missing: false,
+        };
+    }
+    catch {
+        return {
+            path: file.path,
+            addedAt: file.addedAt,
+            tokens: file.tokens,
+            content: '',
+            missing: true,
+        };
+    }
+}
+function loadPersistentMemory(cwd, storePath) {
+    const memory = new PersistentMemory(storePath);
+    memory.load(memory.getProjectId(cwd));
+    return cloneMemoryEntries(memory.recall());
+}
+function restorePersistentMemory(cwd, entries) {
+    const memory = new PersistentMemory();
+    const projectId = memory.getProjectId(cwd);
+    for (const entry of entries) {
+        memory.remember(entry.key, entry.value, entry.source);
+    }
+    memory.save(projectId);
+}
+function buildImportedContextMessage(bundle) {
+    const lines = [
+        'Imported handoff bundle context.',
+        `Author: ${bundle.metadata.author}`,
+        `Timestamp: ${bundle.metadata.timestamp}`,
+        `Branch: ${bundle.metadata.branch || '(unknown)'}`,
+    ];
+    if (bundle.metadata.description) {
+        lines.push(`Description: ${bundle.metadata.description}`);
+    }
+    if (bundle.context.memory.length) {
+        lines.push('', 'Persistent memory:');
+        for (const entry of bundle.context.memory) {
+            lines.push(`- ${entry.key}: ${entry.value} (${entry.source}, ${entry.addedAt})`);
+        }
+    }
+    if (bundle.context.files.length) {
+        lines.push('', 'Pinned file snapshots:');
+        for (const file of bundle.context.files) {
+            lines.push('', `File: ${file.path}`);
+            if (file.missing) {
+                lines.push('[snapshot unavailable]');
+                continue;
+            }
+            lines.push('```');
+            lines.push(file.content);
+            lines.push('```');
+        }
+    }
+    return lines.join('\n');
+}
+function detectAuthor() {
+    return (process.env.GIT_AUTHOR_NAME?.trim() ||
+        process.env.GIT_COMMITTER_NAME?.trim() ||
+        process.env.USERNAME?.trim() ||
+        process.env.USER?.trim() ||
+        'unknown');
+}
+function detectBranch(cwd) {
+    try {
+        return execSync('git rev-parse --abbrev-ref HEAD', {
+            cwd,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+function resolveHandoffPath(cwd, targetPath) {
+    if (!targetPath?.trim())
+        return path.resolve(cwd, DEFAULT_FILENAME);
+    const resolved = path.resolve(cwd, targetPath.trim());
+    try {
+        if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+            return path.join(resolved, DEFAULT_FILENAME);
+        }
+    }
+    catch {
+        /* ignore stat errors */
+    }
+    return resolved;
+}
+function cloneMessages(messages) {
+    if (!Array.isArray(messages))
+        return [];
+    return JSON.parse(JSON.stringify(messages));
+}
+function cloneTodos(todos) {
+    if (!Array.isArray(todos))
+        return [];
+    return todos.flatMap((todo) => {
+        if (!todo || typeof todo !== 'object')
+            return [];
+        const candidate = todo;
+        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,
+                completedAt: typeof candidate.completedAt === 'string' ? candidate.completedAt : undefined,
+            },
+        ];
+    });
+}
+function clonePinned(files) {
+    if (!Array.isArray(files))
+        return [];
+    return files.flatMap((file) => {
+        if (!file || typeof file !== 'object')
+            return [];
+        const candidate = file;
+        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 cloneGitContext(files) {
+    if (!Array.isArray(files))
+        return [];
+    return files.flatMap((file) => {
+        if (!file || typeof file !== 'object')
+            return [];
+        const candidate = file;
+        if (typeof candidate.path !== 'string' || typeof candidate.status !== 'string') {
+            return [];
+        }
+        return [
+            {
+                path: candidate.path,
+                status: candidate.status,
+            },
+        ];
+    });
+}
+function cloneMemoryEntries(entries) {
+    if (!Array.isArray(entries))
+        return [];
+    return entries.flatMap((entry) => {
+        if (!entry || typeof entry !== 'object')
+            return [];
+        const candidate = entry;
+        if (typeof candidate.key !== 'string' ||
+            typeof candidate.value !== 'string' ||
+            typeof candidate.addedAt !== 'string' ||
+            (candidate.source !== 'user' && candidate.source !== 'auto')) {
+            return [];
+        }
+        return [
+            {
+                key: candidate.key,
+                value: candidate.value,
+                addedAt: candidate.addedAt,
+                source: candidate.source,
+            },
+        ];
+    });
+}

package/dist/session/manager.js

@@ -0,0 +1,35 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { select } from '@inquirer/prompts';
+import { Session } from './session.js';
+export async function pickSession() {
+    const sessions = Session.list();
+    if (!sessions.length)
+        return null;
+    return select({
+        message: 'Resume session',
+        choices: sessions.map((s) => ({
+            name: `${s.id.slice(0, 8)}  ${s.model}  ${s.messageCount} msgs  ${age(s.mtime)}`,
+            value: s.id,
+            description: s.file,
+        })),
+    }).catch(() => null);
+}
+export async function exportSession(session, format, outPath) {
+    const target = path.resolve(session.state.cwd, outPath || `session-${session.state.id}.${format}`);
+    await fs.mkdir(path.dirname(target), { recursive: true });
+    await fs.writeFile(target, format === 'json' ? session.toJSON() + '\n' : session.toMarkdown(), 'utf8');
+    return target;
+}
+function age(date) {
+    const seconds = Math.max(0, Math.floor((Date.now() - date.getTime()) / 1000));
+    if (seconds < 60)
+        return `${seconds}s ago`;
+    const minutes = Math.floor(seconds / 60);
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.floor(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    return `${Math.floor(hours / 24)}d ago`;
+}