@bahulam/code 2.6.0

package/src/core/scheduler.mjs

@@ -0,0 +1,173 @@
+/**
+ * Scheduler — cron-based task scheduling.
+ *
+ * Stores scheduled tasks in ~/.claude/scheduled_tasks.json.
+ * Tasks have a cron expression, prompt, and optional environment.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+export class Scheduler {
+    /**
+     * @param {string} [tasksFile] - path to scheduled tasks JSON
+     */
+    constructor(tasksFile) {
+        this.tasksFile = tasksFile ||
+            path.join(os.homedir(), '.claude', 'scheduled_tasks.json');
+        this.timers = new Map();
+    }
+
+    /**
+     * Create a new scheduled task.
+     * @param {string} cron - cron expression or interval shorthand (e.g., "5m", "1h")
+     * @param {string} prompt - prompt to execute
+     * @param {object} [options]
+     * @param {string} [options.name] - human-readable name
+     * @param {string} [options.model] - model to use
+     * @param {boolean} [options.enabled] - whether task is enabled (default: true)
+     * @returns {object} created task
+     */
+    async create(cron, prompt, options = {}) {
+        const tasks = this._loadTasks();
+        const task = {
+            id: `task_${crypto.randomBytes(4).toString('hex')}`,
+            name: options.name || `Task ${tasks.length + 1}`,
+            cron,
+            prompt,
+            model: options.model || null,
+            enabled: options.enabled !== false,
+            createdAt: new Date().toISOString(),
+            lastRun: null,
+            runCount: 0,
+            intervalMs: parseCronInterval(cron),
+        };
+
+        tasks.push(task);
+        this._saveTasks(tasks);
+        return task;
+    }
+
+    /**
+     * Delete a scheduled task by ID.
+     * @param {string} taskId
+     * @returns {boolean} true if deleted
+     */
+    async delete(taskId) {
+        const tasks = this._loadTasks();
+        const idx = tasks.findIndex(t => t.id === taskId);
+        if (idx === -1) return false;
+
+        tasks.splice(idx, 1);
+        this._saveTasks(tasks);
+
+        // Clear timer if running
+        if (this.timers.has(taskId)) {
+            clearInterval(this.timers.get(taskId));
+            this.timers.delete(taskId);
+        }
+
+        return true;
+    }
+
+    /**
+     * List all scheduled tasks.
+     * @returns {Array<object>}
+     */
+    async list() {
+        return this._loadTasks();
+    }
+
+    /**
+     * Check and return tasks that are due to run.
+     * @returns {Array<object>} tasks that are due
+     */
+    async runDue() {
+        const tasks = this._loadTasks();
+        const due = [];
+        const now = Date.now();
+
+        for (const task of tasks) {
+            if (!task.enabled) continue;
+            if (!task.intervalMs) continue;
+
+            const lastRun = task.lastRun ? new Date(task.lastRun).getTime() : 0;
+            if (now - lastRun >= task.intervalMs) {
+                task.lastRun = new Date().toISOString();
+                task.runCount = (task.runCount || 0) + 1;
+                due.push(task);
+            }
+        }
+
+        if (due.length > 0) {
+            this._saveTasks(tasks);
+        }
+
+        return due;
+    }
+
+    /**
+     * Enable or disable a task.
+     * @param {string} taskId
+     * @param {boolean} enabled
+     * @returns {boolean}
+     */
+    async setEnabled(taskId, enabled) {
+        const tasks = this._loadTasks();
+        const task = tasks.find(t => t.id === taskId);
+        if (!task) return false;
+
+        task.enabled = enabled;
+        this._saveTasks(tasks);
+        return true;
+    }
+
+    /**
+     * Load tasks from disk.
+     * @returns {Array<object>}
+     */
+    _loadTasks() {
+        try {
+            const raw = fs.readFileSync(this.tasksFile, 'utf-8');
+            return JSON.parse(raw);
+        } catch {
+            return [];
+        }
+    }
+
+    /**
+     * Save tasks to disk.
+     * @param {Array<object>} tasks
+     */
+    _saveTasks(tasks) {
+        try {
+            const dir = path.dirname(this.tasksFile);
+            fs.mkdirSync(dir, { recursive: true });
+            fs.writeFileSync(this.tasksFile, JSON.stringify(tasks, null, 2));
+        } catch {
+            // Best effort
+        }
+    }
+}
+
+/**
+ * Parse a cron expression or interval shorthand into milliseconds.
+ * @param {string} cron
+ * @returns {number}
+ */
+export function parseCronInterval(cron) {
+    const match = cron.match(/^(\d+)(s|m|h|d)$/);
+    if (match) {
+        const value = parseInt(match[1], 10);
+        const units = { s: 1000, m: 60000, h: 3600000, d: 86400000 };
+        return value * (units[match[2]] || 60000);
+    }
+
+    const num = parseInt(cron, 10);
+    if (!isNaN(num)) return num * 60000;
+
+    // Full cron expression — default to 5 minutes
+    return 300000;
+}

package/src/core/session-manager.mjs

@@ -0,0 +1,360 @@
+/**
+ * Session Manager — persist session state, history, and conversation messages.
+ *
+ * All data lives under ~/.bahulam/:
+ *   ~/.bahulam/
+ *     projects/{hash}/
+ *       state.json              — current session metadata
+ *       sessions/               — session metadata archive
+ *     conversations/
+ *       {sessionId}.jsonl       — conversation messages (JSONL)
+ *         Line 1: {"type":"header","instruction":"...","project":"..."}
+ *         Line 2+: {"role":"user","content":"...","timestamp":"..."}
+ *
+ * Zero per-project files. /resume works from anywhere.
+ */
+
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import {
+    projectDir as getProjectDir,
+    statePath as getStatePath,
+    sessionsDir as getSessionsDir,
+    conversationsDir as getConversationsDir,
+    conversationPath as getConversationPath,
+} from './paths.mjs';
+
+const MAX_SESSIONS = 100;
+
+export class SessionManager {
+    constructor(projectPath = process.cwd()) {
+        this.projectPath = projectPath;
+        this.projectKeplerDir = getProjectDir(projectPath);
+        this.statePath = getStatePath(projectPath);
+        this.sessionsDir = getSessionsDir(projectPath);
+        this.conversationsDir = getConversationsDir();
+        this.currentState = null;
+    }
+
+    _ensureDirs() {
+        fs.mkdirSync(this.projectKeplerDir, { recursive: true });
+        fs.mkdirSync(this.sessionsDir, { recursive: true });
+        fs.mkdirSync(this.conversationsDir, { recursive: true });
+    }
+
+    /** Start tracking a new session. */
+    start(instruction) {
+        this._ensureDirs();
+        this.currentState = {
+            instruction,
+            started_at: new Date().toISOString(),
+            status: 'running',
+            task_id: null,
+            job_id: null,
+            session_id: null,
+            tool_count: 0,
+            turn_count: 0,
+            events: [],
+        };
+        this._writeState();
+    }
+
+    /** Update state from session_info event. */
+    setSessionInfo(data) {
+        if (!this.currentState) return;
+        this.currentState.task_id = data.task_id || this.currentState.task_id;
+        this.currentState.job_id = data.job_id || this.currentState.job_id;
+        this.currentState.session_id = data.session_id || this.currentState.session_id;
+        this._writeState();
+    }
+
+    /** Record a tool call. */
+    recordToolCall(toolName) {
+        if (!this.currentState) return;
+        this.currentState.tool_count++;
+    }
+
+    /** Mark session as complete. */
+    complete(summary) {
+        if (!this.currentState) return;
+        this.currentState.status = 'completed';
+        this.currentState.completed_at = new Date().toISOString();
+        this.currentState.summary = summary;
+        const duration = (Date.now() - new Date(this.currentState.started_at).getTime()) / 1000;
+        this.currentState.duration_s = Math.round(duration * 10) / 10;
+        this._writeState();
+        this._saveToHistory();
+    }
+
+    /** Mark session as failed. */
+    fail(errorMessage) {
+        if (!this.currentState) return;
+        this.currentState.status = 'failed';
+        this.currentState.error = errorMessage;
+        this.currentState.completed_at = new Date().toISOString();
+        this._writeState();
+        this._saveToHistory();
+    }
+
+    /** Mark session as cancelled. */
+    cancel() {
+        if (!this.currentState) return;
+        this.currentState.status = 'cancelled';
+        this.currentState.completed_at = new Date().toISOString();
+        this._writeState();
+        this._saveToHistory();
+    }
+
+    /** Mark session as paused. */
+    pause() {
+        if (!this.currentState) return;
+        this.currentState.status = 'paused';
+        this._writeState();
+    }
+
+    /** Load saved state for resume. */
+    loadState() {
+        try {
+            if (fs.existsSync(this.statePath)) {
+                return JSON.parse(fs.readFileSync(this.statePath, 'utf-8'));
+            }
+        } catch { /* corrupt file */ }
+        return null;
+    }
+
+    /** List recent sessions. */
+    listSessions(limit = 20) {
+        if (!fs.existsSync(this.sessionsDir)) return [];
+        return fs.readdirSync(this.sessionsDir)
+            .filter(f => f.endsWith('.json'))
+            .sort()
+            .reverse()
+            .slice(0, limit)
+            .map(file => {
+                try {
+                    const data = JSON.parse(fs.readFileSync(path.join(this.sessionsDir, file), 'utf-8'));
+                    return { file, ...data };
+                } catch {
+                    return { file, status: 'unreadable' };
+                }
+            });
+    }
+
+    // ── Conversation Persistence ──
+
+    /**
+     * Get the JSONL file path for a session's conversation.
+     * @param {string} [sessionId] - defaults to current session
+     */
+    _conversationPath(sessionId) {
+        const id = sessionId || this.currentState?.session_id || this.currentState?.task_id || 'unknown';
+        return getConversationPath(id);
+    }
+
+    /**
+     * Append a message to the conversation JSONL file.
+     * On first write, prepends a header line with session metadata.
+     * @param {string} role - 'user' or 'assistant'
+     * @param {string} content - message content
+     * @param {object} [meta] - optional metadata (tokens, cost, tools)
+     */
+    saveMessage(role, content, meta = {}) {
+        if (!this.currentState) return;
+        this._ensureDirs();
+
+        const convPath = this._conversationPath();
+
+        // Write header line on first message (so listResumable can read metadata)
+        if (!fs.existsSync(convPath)) {
+            const header = {
+                type: 'header',
+                instruction: this.currentState.instruction || '',
+                project: this.projectPath,
+                project_name: path.basename(this.projectPath),
+                started_at: this.currentState.started_at || new Date().toISOString(),
+                session_id: this.currentState.session_id || '',
+            };
+            fs.appendFileSync(convPath, JSON.stringify(header) + '\n');
+        }
+
+        const entry = {
+            role,
+            content,
+            timestamp: new Date().toISOString(),
+            turn: this.currentState.turn_count || 0,
+            ...meta,
+        };
+
+        fs.appendFileSync(convPath, JSON.stringify(entry) + '\n');
+    }
+
+    /**
+     * Read the header line from a conversation JSONL file.
+     * @param {string} filePath
+     * @returns {object|null}
+     */
+    _readHeader(filePath) {
+        try {
+            const first = fs.readFileSync(filePath, 'utf-8').split('\n')[0];
+            if (!first) return null;
+            const parsed = JSON.parse(first);
+            return parsed.type === 'header' ? parsed : null;
+        } catch {
+            return null;
+        }
+    }
+
+    /**
+     * Load all messages from a session's conversation file (skips header).
+     * @param {string} sessionId - session to load
+     * @returns {{ role: string, content: string }[]}
+     */
+    loadMessages(sessionId) {
+        return this.loadConversation(sessionId).messages;
+    }
+
+    /**
+     * Load the header and all messages from a session conversation file.
+     * @param {string} sessionId
+     * @returns {{ header: object|null, messages: { role: string, content: string }[] }}
+     */
+    loadConversation(sessionId) {
+        const filePath = this._conversationPath(sessionId);
+        if (!fs.existsSync(filePath)) return { header: null, messages: [] };
+
+        const lines = fs.readFileSync(filePath, 'utf-8').split('\n').filter(Boolean);
+        const entries = lines
+            .map(line => {
+                try { return JSON.parse(line); } catch { return null; }
+            })
+            .filter(Boolean);
+        const header = entries.find(entry => entry.type === 'header') || null;
+        const messages = entries
+            .filter(entry => entry.role) // skip header (type=header, no role)
+            .map(entry => ({ role: entry.role, content: entry.content }));
+        return { header, messages };
+    }
+
+    /**
+     * Activate an existing conversation as the current session so additional
+     * turns append to the same JSONL file.
+     * @param {string} sessionId
+     * @param {object|null} header
+     * @param {{ role: string, content: string }[]} messages
+     */
+    activateSession(sessionId, header = null, messages = []) {
+        this._ensureDirs();
+        this.currentState = {
+            instruction: header?.instruction || messages.find(m => m.role === 'user')?.content || '',
+            started_at: header?.started_at || new Date().toISOString(),
+            status: 'running',
+            task_id: null,
+            job_id: null,
+            session_id: sessionId,
+            tool_count: 0,
+            turn_count: messages.filter(m => m.role === 'user').length,
+            events: [],
+            resumed_at: new Date().toISOString(),
+        };
+        this._writeState();
+        return this.currentState;
+    }
+
+    /**
+     * Get the most recent session that has a conversation file.
+     * @returns {{ sessionId: string, instruction: string, startedAt: string }|null}
+     */
+    getLastSession() {
+        if (!fs.existsSync(this.conversationsDir)) return null;
+
+        // Sort by file modification time (most recent first)
+        const files = fs.readdirSync(this.conversationsDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => ({
+                name: f,
+                mtime: fs.statSync(path.join(this.conversationsDir, f)).mtimeMs,
+            }))
+            .sort((a, b) => b.mtime - a.mtime);
+
+        if (files.length === 0) return null;
+
+        const file = files[0].name;
+        const sessionId = file.replace('.jsonl', '');
+        const header = this._readHeader(path.join(this.conversationsDir, file));
+
+        return {
+            sessionId,
+            instruction: header?.instruction || '',
+            startedAt: header?.started_at || '',
+            project: header?.project_name || '',
+            projectPath: header?.project || '',
+        };
+    }
+
+    /**
+     * List sessions that have conversation history (resumable).
+     * Reads metadata from JSONL header line — no cross-referencing needed.
+     * @param {number} [limit=Infinity]
+     * @returns {Array<{ sessionId, instruction, startedAt, updatedAt, project, messageCount }>}
+     */
+    listResumable(limit = Infinity) {
+        if (!fs.existsSync(this.conversationsDir)) return [];
+
+        // Sort by latest activity (conversation file mtime) so resumed sessions
+        // move back to the top. The UI displays this same timestamp.
+        const files = fs.readdirSync(this.conversationsDir)
+            .filter(f => f.endsWith('.jsonl'))
+            .map(f => ({
+                name: f,
+                mtime: fs.statSync(path.join(this.conversationsDir, f)).mtimeMs,
+            }))
+            .sort((a, b) => b.mtime - a.mtime);
+
+        const limited = Number.isFinite(limit) ? files.slice(0, limit) : files;
+
+        return limited.map(({ name, mtime }) => {
+            const sessionId = name.replace('.jsonl', '');
+            const convPath = path.join(this.conversationsDir, name);
+            const lines = fs.readFileSync(convPath, 'utf-8').split('\n').filter(Boolean);
+            const header = this._readHeader(convPath);
+
+            // Message count = total lines minus header
+            const messageCount = header ? lines.length - 1 : lines.length;
+
+            return {
+                sessionId,
+                instruction: header?.instruction || '(no instruction)',
+                startedAt: header?.started_at || '',
+                updatedAt: new Date(mtime).toISOString(),
+                project: header?.project_name || '',
+                projectPath: header?.project || '',
+                messageCount,
+            };
+        });
+    }
+
+    _writeState() {
+        this._ensureDirs();
+        fs.writeFileSync(this.statePath, JSON.stringify(this.currentState, null, 2));
+    }
+
+    _saveToHistory() {
+        this._ensureDirs();
+        const filename = this.currentState.started_at.replace(/[:.]/g, '-') + '.json';
+        fs.writeFileSync(
+            path.join(this.sessionsDir, filename),
+            JSON.stringify(this.currentState, null, 2)
+        );
+        this._pruneHistory();
+    }
+
+    _pruneHistory() {
+        const files = fs.readdirSync(this.sessionsDir)
+            .filter(f => f.endsWith('.json'))
+            .sort();
+        while (files.length > MAX_SESSIONS) {
+            const oldest = files.shift();
+            try { fs.unlinkSync(path.join(this.sessionsDir, oldest)); } catch {}
+        }
+    }
+}

package/src/core/session.mjs

@@ -0,0 +1,143 @@
+/**
+ * Session Manager — save, resume, and teleport sessions.
+ *
+ * Sessions are stored at ~/.claude/projects/<hash>/session.json
+ * and contain conversation history, token usage, and metadata.
+ */
+
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import crypto from 'crypto';
+
+export class SessionManager {
+    constructor(projectDir = process.cwd()) {
+        this.projectDir = projectDir;
+        this.sessionId = `sess_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
+        this.conversationId = null;
+        this.startedAt = new Date().toISOString();
+    }
+
+    /**
+     * Get the session storage directory for the current project.
+     */
+    getSessionDir() {
+        const hash = crypto.createHash('sha256')
+            .update(this.projectDir)
+            .digest('hex')
+            .slice(0, 16);
+
+        return path.join(os.homedir(), '.claude', 'projects', hash);
+    }
+
+    /**
+     * Save the current session state.
+     * @param {object} state - agent loop state to save
+     */
+    save(state) {
+        const dir = this.getSessionDir();
+        fs.mkdirSync(dir, { recursive: true });
+
+        const session = {
+            id: this.sessionId,
+            conversationId: this.conversationId,
+            projectDir: this.projectDir,
+            startedAt: this.startedAt,
+            savedAt: new Date().toISOString(),
+            model: state.model,
+            turnCount: state.turnCount,
+            tokenUsage: state.tokenUsage,
+            messages: state.messages,
+            systemPrompt: state.systemPrompt,
+        };
+
+        const filePath = path.join(dir, 'session.json');
+        fs.writeFileSync(filePath, JSON.stringify(session, null, 2));
+        return filePath;
+    }
+
+    /**
+     * Resume a saved session.
+     * @param {object} state - agent loop state to restore into
+     * @returns {boolean} true if session was restored
+     */
+    resume(state) {
+        const dir = this.getSessionDir();
+        const filePath = path.join(dir, 'session.json');
+
+        try {
+            const raw = fs.readFileSync(filePath, 'utf-8');
+            const session = JSON.parse(raw);
+
+            state.messages = session.messages || [];
+            state.turnCount = session.turnCount || 0;
+            state.tokenUsage = session.tokenUsage || { input: 0, output: 0 };
+            if (session.model) state.model = session.model;
+
+            this.sessionId = session.id;
+            this.conversationId = session.conversationId;
+            this.startedAt = session.startedAt;
+
+            return true;
+        } catch {
+            return false;
+        }
+    }
+
+    /**
+     * Export session for teleport (transfer between machines).
+     * @param {object} state - agent loop state
+     * @returns {string} base64-encoded session data
+     */
+    exportForTeleport(state) {
+        const session = {
+            id: this.sessionId,
+            projectDir: this.projectDir,
+            messages: state.messages,
+            turnCount: state.turnCount,
+            model: state.model,
+            exportedAt: new Date().toISOString(),
+        };
+
+        return Buffer.from(JSON.stringify(session)).toString('base64');
+    }
+
+    /**
+     * Import a teleported session.
+     * @param {string} data - base64-encoded session data
+     * @param {object} state - agent loop state to restore into
+     */
+    importFromTeleport(data, state) {
+        const session = JSON.parse(Buffer.from(data, 'base64').toString());
+        state.messages = session.messages || [];
+        state.turnCount = session.turnCount || 0;
+        if (session.model) state.model = session.model;
+        this.sessionId = `sess_teleport_${Date.now()}`;
+    }
+
+    /**
+     * Get session info.
+     */
+    info() {
+        return {
+            id: this.sessionId,
+            conversationId: this.conversationId,
+            projectDir: this.projectDir,
+            startedAt: this.startedAt,
+            sessionDir: this.getSessionDir(),
+        };
+    }
+
+    /**
+     * Delete the saved session.
+     */
+    clear() {
+        const filePath = path.join(this.getSessionDir(), 'session.json');
+        try {
+            fs.unlinkSync(filePath);
+            return true;
+        } catch {
+            return false;
+        }
+    }
+}