@jellyos/agent 0.1.4 → 0.1.5

package/dist/session/ContextStore.d.ts

@@ -0,0 +1,96 @@
+/**
+ * ContextStore — Ephemeral task context folders. (#31, #39)
+ *
+ * When an agent task takes >2 tool rounds, a ~/.jelly/tasks/<id>/context.md
+ * file is created. Intermediate tool results are appended there instead of
+ * bloating the message history. The model gets a compact file reference
+ * instead of 10KB of raw JSON. The folder auto-deletes on task completion
+ * unless the user marked it /keep.
+ *
+ * This is the primary mechanism that allows turbo/max mode to stay within
+ * context budget even on complex multi-step research tasks.
+ */
+export interface TaskContext {
+    taskId: string;
+    taskDir: string;
+    contextMd: string;
+    createdAt: number;
+    title: string;
+    keep: boolean;
+    findings: number;
+}
+export declare class ContextStore {
+    private activeTasks;
+    constructor();
+    /** Open a new ephemeral task folder. Returns the TaskContext. */
+    openTask(title: string, keep?: boolean): TaskContext;
+    /** Append a finding / tool result to the task's context.md */
+    appendFinding(taskId: string, section: string, content: string): void;
+    /**
+     * Get a compact reference string for injection into the model context.
+     * Returns something like:
+     * "[Task ctx: ~/.jelly/tasks/.../context.md — 4 findings, 3.2KB. Use read_task_context("abc123")]"
+     */
+    getReference(taskId: string): string;
+    /**
+     * Mark a task complete and optionally delete its folder.
+     * Deletion is deferred 5 seconds to allow model to read final state.
+     */
+    closeTask(taskId: string): void;
+    /** Permanently keep a task folder (user called /keep <taskId>) */
+    keepTask(taskId: string): boolean;
+    getActiveTasks(): TaskContext[];
+    getTask(taskId: string): TaskContext | undefined;
+    readContextTool(_id: string, { taskId }: {
+        taskId: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId: string;
+            path: string;
+            sizeBytes: number;
+            status: string;
+            findings?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId?: undefined;
+            path?: undefined;
+            sizeBytes?: undefined;
+            status?: undefined;
+            findings?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            taskId: string;
+            path: string;
+            sizeBytes: number;
+            findings: number;
+            status: string;
+        };
+    }>;
+    listTasksTool(): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            activeTasks: number;
+            completedOnDisk: number;
+        };
+    }>;
+}
+/** Singleton — one store per process */
+export declare const contextStore: ContextStore;
+//# sourceMappingURL=ContextStore.d.ts.map

package/dist/session/ContextStore.js

@@ -0,0 +1,207 @@
+/**
+ * ContextStore — Ephemeral task context folders. (#31, #39)
+ *
+ * When an agent task takes >2 tool rounds, a ~/.jelly/tasks/<id>/context.md
+ * file is created. Intermediate tool results are appended there instead of
+ * bloating the message history. The model gets a compact file reference
+ * instead of 10KB of raw JSON. The folder auto-deletes on task completion
+ * unless the user marked it /keep.
+ *
+ * This is the primary mechanism that allows turbo/max mode to stay within
+ * context budget even on complex multi-step research tasks.
+ */
+import { mkdirSync, writeFileSync, rmSync, existsSync, readFileSync, readdirSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+const TASKS_DIR = join(JELLY_HOME, "tasks");
+export class ContextStore {
+    activeTasks = new Map();
+    constructor() {
+        mkdirSync(TASKS_DIR, { recursive: true });
+    }
+    // ── Task lifecycle ─────────────────────────────────────────────────────────
+    /** Open a new ephemeral task folder. Returns the TaskContext. */
+    openTask(title, keep = false) {
+        const taskId = randomUUID().slice(0, 8);
+        const taskDir = join(TASKS_DIR, `${Date.now()}-${taskId}`);
+        const contextMd = join(taskDir, "context.md");
+        mkdirSync(taskDir, { recursive: true });
+        writeFileSync(contextMd, [
+            `# Task: ${title.slice(0, 120)}`,
+            `**ID:** ${taskId}`,
+            `**Started:** ${new Date().toISOString()}`,
+            `**Status:** in_progress`,
+            ``,
+            `## Findings`,
+            ``,
+        ].join("\n"), "utf-8");
+        const ctx = {
+            taskId, taskDir, contextMd,
+            createdAt: Date.now(), title, keep, findings: 0,
+        };
+        this.activeTasks.set(taskId, ctx);
+        return ctx;
+    }
+    /** Append a finding / tool result to the task's context.md */
+    appendFinding(taskId, section, content) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx || !existsSync(ctx.contextMd))
+            return;
+        // Cap individual entries at 3KB to prevent runaway growth
+        const cappedContent = content.length > 3000
+            ? content.slice(0, 3000) + `\n\n…[truncated ${content.length - 3000} chars]`
+            : content;
+        const entry = [
+            `### ${section}`,
+            `_${new Date().toLocaleTimeString()}_`,
+            ``,
+            cappedContent,
+            ``,
+            `---`,
+            ``,
+        ].join("\n");
+        const existing = readFileSync(ctx.contextMd, "utf-8");
+        writeFileSync(ctx.contextMd, existing + entry, "utf-8");
+        ctx.findings++;
+    }
+    /**
+     * Get a compact reference string for injection into the model context.
+     * Returns something like:
+     * "[Task ctx: ~/.jelly/tasks/.../context.md — 4 findings, 3.2KB. Use read_task_context("abc123")]"
+     */
+    getReference(taskId) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx || !existsSync(ctx.contextMd))
+            return "";
+        const content = readFileSync(ctx.contextMd, "utf-8");
+        const sizeKB = (content.length / 1024).toFixed(1);
+        return `[Task context saved: ${ctx.contextMd} — ${ctx.findings} findings, ${sizeKB}KB. ` +
+            `To read back: use tool read_task_context with taskId="${taskId}"]`;
+    }
+    /**
+     * Mark a task complete and optionally delete its folder.
+     * Deletion is deferred 5 seconds to allow model to read final state.
+     */
+    closeTask(taskId) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx)
+            return;
+        // Update status in the file
+        if (existsSync(ctx.contextMd)) {
+            try {
+                const content = readFileSync(ctx.contextMd, "utf-8");
+                writeFileSync(ctx.contextMd, content
+                    .replace("**Status:** in_progress", `**Status:** completed\n**Completed:** ${new Date().toISOString()}`), "utf-8");
+            }
+            catch { /* best effort */ }
+        }
+        if (!ctx.keep) {
+            // Deferred delete — give agent 5s to read final context if needed
+            setTimeout(() => {
+                try {
+                    rmSync(ctx.taskDir, { recursive: true, force: true });
+                }
+                catch { /* ignore */ }
+            }, 5_000);
+        }
+        this.activeTasks.delete(taskId);
+    }
+    /** Permanently keep a task folder (user called /keep <taskId>) */
+    keepTask(taskId) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx)
+            return false;
+        ctx.keep = true;
+        return true;
+    }
+    getActiveTasks() {
+        return [...this.activeTasks.values()];
+    }
+    getTask(taskId) {
+        return this.activeTasks.get(taskId);
+    }
+    // ── Tool: read_task_context ────────────────────────────────────────────────
+    async readContextTool(_id, { taskId }) {
+        const ctx = this.activeTasks.get(taskId);
+        if (!ctx) {
+            // Try to find a completed task folder on disk by taskId suffix
+            const dirs = existsSync(TASKS_DIR) ? readdirSync(TASKS_DIR) : [];
+            const dir = dirs.find(d => d.endsWith(`-${taskId}`));
+            if (dir) {
+                const mdPath = join(TASKS_DIR, dir, "context.md");
+                if (existsSync(mdPath)) {
+                    const content = readFileSync(mdPath, "utf-8");
+                    return {
+                        content: [{ type: "text", text: content }],
+                        details: { taskId, path: mdPath, sizeBytes: content.length, status: "archived" },
+                    };
+                }
+            }
+            return {
+                content: [{ type: "text", text: `Task "${taskId}" not found. It may have been deleted after completion.` }],
+                details: {},
+            };
+        }
+        if (!existsSync(ctx.contextMd)) {
+            return {
+                content: [{ type: "text", text: `Context file missing for task "${taskId}".` }],
+                details: {},
+            };
+        }
+        const content = readFileSync(ctx.contextMd, "utf-8");
+        return {
+            content: [{ type: "text", text: content }],
+            details: {
+                taskId,
+                path: ctx.contextMd,
+                sizeBytes: content.length,
+                findings: ctx.findings,
+                status: "active",
+            },
+        };
+    }
+    // ── Tool: list_tasks ───────────────────────────────────────────────────────
+    async listTasksTool() {
+        const active = this.getActiveTasks();
+        // Also scan disk for recent completed tasks
+        const onDisk = [];
+        if (existsSync(TASKS_DIR)) {
+            const dirs = readdirSync(TASKS_DIR).slice(-10); // last 10
+            for (const d of dirs) {
+                const mdPath = join(TASKS_DIR, d, "context.md");
+                if (existsSync(mdPath)) {
+                    const size = (readFileSync(mdPath, "utf-8").length / 1024).toFixed(1);
+                    const id = d.split("-").pop() ?? d;
+                    if (!this.activeTasks.has(id))
+                        onDisk.push({ dir: d, id, sizeKB: size });
+                }
+            }
+        }
+        const lines = [];
+        if (active.length > 0) {
+            lines.push(`Active tasks (${active.length}):`);
+            for (const t of active) {
+                const mdContent = existsSync(t.contextMd) ? readFileSync(t.contextMd, "utf-8") : "";
+                const sizeKB = (mdContent.length / 1024).toFixed(1);
+                lines.push(`  📁 [${t.taskId}] ${t.title.slice(0, 50)} — ${t.findings} findings, ${sizeKB}KB`);
+            }
+        }
+        if (onDisk.length > 0) {
+            lines.push(`\nRecent completed tasks:`);
+            for (const t of onDisk) {
+                lines.push(`  📄 [${t.id}] ${t.dir.slice(14, 64)} — ${t.sizeKB}KB`);
+            }
+        }
+        if (lines.length === 0)
+            lines.push("No active or recent task contexts.");
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            details: { activeTasks: active.length, completedOnDisk: onDisk.length },
+        };
+    }
+}
+/** Singleton — one store per process */
+export const contextStore = new ContextStore();
+//# sourceMappingURL=ContextStore.js.map

package/dist/session/GoalManager.d.ts

@@ -0,0 +1,101 @@
+/**
+ * GoalManager — cross-session persistent goal tracking. (#12)
+ *
+ * Goals set in one session survive restarts and are injected into the
+ * system prompt on every subsequent session. This gives the agent
+ * continuity — it knows what it was asked to watch or do.
+ *
+ * Stored in ~/.jelly/goals.json
+ * Tools: set_goal, complete_goal, list_goals, update_goal_notes
+ * Commands: /goals, /goal add <text>, /goal done <id>
+ */
+import { type Static } from "@sinclair/typebox";
+export interface Goal {
+    id: string;
+    text: string;
+    createdAt: number;
+    updatedAt: number;
+    status: "active" | "completed" | "paused";
+    notes: string[];
+}
+export declare class GoalManager {
+    private goals;
+    constructor();
+    private load;
+    private save;
+    add(text: string): Goal;
+    complete(id: string): boolean;
+    pause(id: string): boolean;
+    addNote(id: string, note: string): boolean;
+    getActive(): Goal[];
+    getAll(): Goal[];
+    get(id: string): Goal | undefined;
+    /** Build an active goals block for injection into the system prompt */
+    buildContextBlock(): string;
+    readonly setGoalParams: import("@sinclair/typebox").TObject<{
+        text: import("@sinclair/typebox").TString;
+    }>;
+    setGoalTool(_id: string, params: Static<typeof this.setGoalParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            goalId: string;
+            text: string;
+        };
+    }>;
+    readonly completeGoalParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        note: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    completeGoalTool(_id: string, params: Static<typeof this.completeGoalParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            goalId: string;
+            success: boolean;
+        };
+    }>;
+    readonly listGoalsParams: import("@sinclair/typebox").TObject<{
+        status: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    }>;
+    listGoalsTool(_id: string, params: Static<typeof this.listGoalsParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            count?: undefined;
+            goals?: undefined;
+        };
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            count: number;
+            goals: Goal[];
+        };
+    }>;
+    readonly addGoalNoteParams: import("@sinclair/typebox").TObject<{
+        id: import("@sinclair/typebox").TString;
+        note: import("@sinclair/typebox").TString;
+    }>;
+    addGoalNoteTool(_id: string, params: Static<typeof this.addGoalNoteParams>): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            goalId: string;
+            success: boolean;
+        };
+    }>;
+}
+/** Singleton */
+export declare const goalManager: GoalManager;
+//# sourceMappingURL=GoalManager.d.ts.map

package/dist/session/GoalManager.js

@@ -0,0 +1,167 @@
+/**
+ * GoalManager — cross-session persistent goal tracking. (#12)
+ *
+ * Goals set in one session survive restarts and are injected into the
+ * system prompt on every subsequent session. This gives the agent
+ * continuity — it knows what it was asked to watch or do.
+ *
+ * Stored in ~/.jelly/goals.json
+ * Tools: set_goal, complete_goal, list_goals, update_goal_notes
+ * Commands: /goals, /goal add <text>, /goal done <id>
+ */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { randomUUID } from "node:crypto";
+import { Type } from "@sinclair/typebox";
+const JELLY_HOME = process.env.JELLYOS_HOME ?? join(homedir(), ".jelly");
+const GOALS_FILE = join(JELLY_HOME, "goals.json");
+export class GoalManager {
+    goals = [];
+    constructor() {
+        this.load();
+    }
+    // ── Persistence ────────────────────────────────────────────────────────────
+    load() {
+        try {
+            if (!existsSync(GOALS_FILE))
+                return;
+            const raw = JSON.parse(readFileSync(GOALS_FILE, "utf-8"));
+            if (Array.isArray(raw))
+                this.goals = raw;
+        }
+        catch { /* start fresh */ }
+    }
+    save() {
+        try {
+            mkdirSync(JELLY_HOME, { recursive: true });
+            writeFileSync(GOALS_FILE, JSON.stringify(this.goals, null, 2), "utf-8");
+        }
+        catch { /* best effort */ }
+    }
+    // ── CRUD ───────────────────────────────────────────────────────────────────
+    add(text) {
+        const goal = {
+            id: randomUUID().slice(0, 8),
+            text: text.trim().slice(0, 500),
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+            status: "active",
+            notes: [],
+        };
+        this.goals.push(goal);
+        this.save();
+        return goal;
+    }
+    complete(id) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.status = "completed";
+        goal.updatedAt = Date.now();
+        this.save();
+        return true;
+    }
+    pause(id) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.status = "paused";
+        goal.updatedAt = Date.now();
+        this.save();
+        return true;
+    }
+    addNote(id, note) {
+        const goal = this.goals.find(g => g.id === id);
+        if (!goal)
+            return false;
+        goal.notes.push(`[${new Date().toLocaleDateString()}] ${note.slice(0, 300)}`);
+        goal.updatedAt = Date.now();
+        if (goal.notes.length > 20)
+            goal.notes = goal.notes.slice(-20); // keep last 20
+        this.save();
+        return true;
+    }
+    getActive() {
+        return this.goals.filter(g => g.status === "active");
+    }
+    getAll() {
+        return [...this.goals];
+    }
+    get(id) {
+        return this.goals.find(g => g.id === id);
+    }
+    // ── System Prompt Block ────────────────────────────────────────────────────
+    /** Build an active goals block for injection into the system prompt */
+    buildContextBlock() {
+        const active = this.getActive();
+        if (active.length === 0)
+            return "";
+        const lines = ["\n## Active Goals (set by user — monitor and act on these)"];
+        for (const g of active) {
+            lines.push(`- [${g.id}] ${g.text}`);
+            if (g.notes.length > 0) {
+                lines.push(`  Last note: ${g.notes[g.notes.length - 1]}`);
+            }
+        }
+        lines.push("");
+        return lines.join("\n");
+    }
+    // ── Tools ──────────────────────────────────────────────────────────────────
+    setGoalParams = Type.Object({
+        text: Type.String({ description: "Goal text e.g. 'Watch ETH for breakout above $4000'" }),
+    });
+    async setGoalTool(_id, params) {
+        const goal = this.add(params.text);
+        return {
+            content: [{ type: "text", text: `Goal set: [${goal.id}] ${goal.text}` }],
+            details: { goalId: goal.id, text: goal.text },
+        };
+    }
+    completeGoalParams = Type.Object({
+        id: Type.String({ description: "Goal ID to mark complete" }),
+        note: Type.Optional(Type.String({ description: "Completion note" })),
+    });
+    async completeGoalTool(_id, params) {
+        if (params.note)
+            this.addNote(params.id, params.note);
+        const ok = this.complete(params.id);
+        return {
+            content: [{ type: "text", text: ok ? `Goal ${params.id} marked complete.` : `Goal ${params.id} not found.` }],
+            details: { goalId: params.id, success: ok },
+        };
+    }
+    listGoalsParams = Type.Object({
+        status: Type.Optional(Type.String({ description: "Filter: active | completed | paused | all (default: active)" })),
+    });
+    async listGoalsTool(_id, params) {
+        const filter = params.status ?? "active";
+        const goals = filter === "all" ? this.getAll() : this.goals.filter(g => g.status === filter);
+        if (goals.length === 0) {
+            return { content: [{ type: "text", text: `No ${filter} goals.` }], details: {} };
+        }
+        const lines = goals.map(g => {
+            const icon = g.status === "active" ? "🎯" : g.status === "completed" ? "✅" : "⏸";
+            const notes = g.notes.length > 0 ? `\n  Notes: ${g.notes[g.notes.length - 1]}` : "";
+            return `${icon} [${g.id}] ${g.text}${notes}`;
+        });
+        return {
+            content: [{ type: "text", text: `Goals (${filter}):\n${lines.join("\n")}` }],
+            details: { count: goals.length, goals },
+        };
+    }
+    addGoalNoteParams = Type.Object({
+        id: Type.String({ description: "Goal ID" }),
+        note: Type.String({ description: "Progress note to add" }),
+    });
+    async addGoalNoteTool(_id, params) {
+        const ok = this.addNote(params.id, params.note);
+        return {
+            content: [{ type: "text", text: ok ? `Note added to goal ${params.id}.` : `Goal ${params.id} not found.` }],
+            details: { goalId: params.id, success: ok },
+        };
+    }
+}
+/** Singleton */
+export const goalManager = new GoalManager();
+//# sourceMappingURL=GoalManager.js.map

package/dist/session/MemoryStore.d.ts

@@ -0,0 +1,48 @@
+/**
+ * MemoryStore — persistent long-term memory using Node 22+ built-in SQLite.
+ * (#7 — cross-session memory)
+ *
+ * Stores all conversation messages, searchable by keyword and session.
+ * Injected into system prompt at session_start to give the agent awareness
+ * of past decisions, prices seen, strategies discussed.
+ *
+ * Uses node:sqlite (experimental in Node 22, stable in Node 24) — zero deps.
+ */
+export interface MemoryEntry {
+    id: number;
+    sessionId: string;
+    role: string;
+    content: string;
+    tokens: number;
+    ts: number;
+    tags: string[];
+}
+export interface RecentSession {
+    sessionId: string;
+    summary: string;
+    msgCount: number;
+    ts: number;
+}
+export declare class MemoryStore {
+    private db;
+    private available;
+    constructor();
+    private init;
+    get isAvailable(): boolean;
+    save(sessionId: string, role: string, content: string, tags?: string[]): void;
+    /** Keyword search across all sessions */
+    search(query: string, limit?: number): MemoryEntry[];
+    /** Get summaries of recent sessions (for system prompt injection) */
+    getRecentSessions(limit?: number): RecentSession[];
+    /** Get all messages for a specific session */
+    getSession(sessionId: string): MemoryEntry[];
+    /** Build a short memory context block for system prompt injection */
+    buildContextBlock(currentSessionId: string): string;
+    getStats(): {
+        totalMessages: number;
+        totalSessions: number;
+    };
+}
+/** Singleton */
+export declare const memoryStore: MemoryStore;
+//# sourceMappingURL=MemoryStore.d.ts.map