@aiaiaichain/agent 0.1.6 → 0.1.7

package/dist/session/GoalManager.js

@@ -1,108 +1,104 @@
-/**
- * GoalManager — persistent cross-session goals for the agent to monitor and complete.
- * Goals are stored in ~/.aiaiai/memory/goals.json
- */
+
 import { existsSync, readFileSync, writeFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { Type } from "@sinclair/typebox";
 import { AgentDir } from "../core/AgentDir.js";
 const GOALS_PATH = resolve(AgentDir.getHome(), "memory", "goals.json");
 export class GoalManager {
-    goals = [];
-    constructor() {
-        this.load();
-    }
-    load() {
-        try {
-            if (existsSync(GOALS_PATH)) {
-                this.goals = JSON.parse(readFileSync(GOALS_PATH, "utf-8"));
-            }
-        }
-        catch {
-            this.goals = [];
-        }
-    }
-    save() {
-        try {
-            writeFileSync(GOALS_PATH, JSON.stringify(this.goals, null, 2), "utf-8");
-        }
-        catch { /* non-fatal */ }
-    }
-    addGoal(text) {
-        const goal = {
-            id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
-            text,
-            status: "active",
-            createdAt: Date.now(),
-            notes: [],
-        };
-        this.goals.push(goal);
-        this.save();
-        return goal;
-    }
-    completeGoal(id) {
-        const goal = this.goals.find(g => g.id === id);
-        if (!goal)
-            return false;
-        goal.status = "completed";
-        goal.completedAt = 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(note);
-        this.save();
-        return true;
-    }
-    listGoals(status) {
-        if (!status || status === "all")
-            return [...this.goals];
-        return this.goals.filter(g => g.status === status);
-    }
-    buildContextBlock() {
-        const active = this.goals.filter(g => g.status === "active");
-        if (active.length === 0)
-            return "";
-        const lines = active.map(g => `  [${g.id}] ${g.text.slice(0, 200)}`);
-        return `\n\n[ACTIVE GOALS]\n${lines.join("\n")}\n`;
-    }
-    // ── Tools ───────────────────────────────────────────────────────────────
-    setGoalParams = Type.Object({
-        text: Type.String({ description: "Goal description" }),
-    });
-    completeGoalParams = Type.Object({
-        id: Type.String({ description: "Goal ID to complete" }),
-    });
-    listGoalsParams = Type.Object({
-        status: Type.Optional(Type.String({ description: "Filter: active, completed, or all" })),
-    });
-    addGoalNoteParams = Type.Object({
-        id: Type.String({ description: "Goal ID" }),
-        note: Type.String({ description: "Progress note" }),
-    });
-    async setGoalTool(_id, params) {
-        const goal = this.addGoal(params.text);
-        return { content: [{ type: "text", text: `Goal created: "${goal.text}" (${goal.id})` }] };
-    }
-    async completeGoalTool(_id, params) {
-        const ok = this.completeGoal(params.id);
-        return { content: [{ type: "text", text: ok ? `Goal ${params.id} completed ✅` : `Goal ${params.id} not found` }] };
-    }
-    async listGoalsTool(_id, params) {
-        const status = params.status || "active";
-        const goals = this.listGoals(status);
-        if (goals.length === 0)
-            return { content: [{ type: "text", text: "No goals found." }] };
-        const lines = goals.map(g => `  ${g.status === "completed" ? "✅" : "🎯"} ${g.id} — ${g.text.slice(0, 120)}${g.notes.length > 0 ? ` (${g.notes.length} notes)` : ""}`);
-        return { content: [{ type: "text", text: `Goals (${goals.length}):\n${lines.join("\n")}` }] };
-    }
-    async addGoalNoteTool(_id, params) {
-        const ok = this.addNote(params.id, params.note);
-        return { content: [{ type: "text", text: ok ? `Note added to ${params.id}` : `Goal ${params.id} not found` }] };
-    }
+goals = [];
+constructor() {
+this.load();
+}
+load() {
+try {
+if (existsSync(GOALS_PATH)) {
+this.goals = JSON.parse(readFileSync(GOALS_PATH, "utf-8"));
+}
+}
+catch {
+this.goals = [];
+}
+}
+save() {
+try {
+writeFileSync(GOALS_PATH, JSON.stringify(this.goals, null, 2), "utf-8");
+}
+catch {  }
+}
+addGoal(text) {
+const goal = {
+id: `goal-${Date.now()}-${Math.random().toString(36).slice(2, 5)}`,
+text,
+status: "active",
+createdAt: Date.now(),
+notes: [],
+};
+this.goals.push(goal);
+this.save();
+return goal;
+}
+completeGoal(id) {
+const goal = this.goals.find(g => g.id === id);
+if (!goal)
+return false;
+goal.status = "completed";
+goal.completedAt = 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(note);
+this.save();
+return true;
+}
+listGoals(status) {
+if (!status || status === "all")
+return [...this.goals];
+return this.goals.filter(g => g.status === status);
+}
+buildContextBlock() {
+const active = this.goals.filter(g => g.status === "active");
+if (active.length === 0)
+return "";
+const lines = active.map(g => `  [${g.id}] ${g.text.slice(0, 200)}`);
+return `\n\n[ACTIVE GOALS]\n${lines.join("\n")}\n`;
+}
+
+setGoalParams = Type.Object({
+text: Type.String({ description: "Goal description" }),
+});
+completeGoalParams = Type.Object({
+id: Type.String({ description: "Goal ID to complete" }),
+});
+listGoalsParams = Type.Object({
+status: Type.Optional(Type.String({ description: "Filter: active, completed, or all" })),
+});
+addGoalNoteParams = Type.Object({
+id: Type.String({ description: "Goal ID" }),
+note: Type.String({ description: "Progress note" }),
+});
+async setGoalTool(_id, params) {
+const goal = this.addGoal(params.text);
+return { content: [{ type: "text", text: `Goal created: "${goal.text}" (${goal.id})` }] };
+}
+async completeGoalTool(_id, params) {
+const ok = this.completeGoal(params.id);
+return { content: [{ type: "text", text: ok ? `Goal ${params.id} completed ✅` : `Goal ${params.id} not found` }] };
+}
+async listGoalsTool(_id, params) {
+const status = params.status || "active";
+const goals = this.listGoals(status);
+if (goals.length === 0)
+return { content: [{ type: "text", text: "No goals found." }] };
+const lines = goals.map(g => `  ${g.status === "completed" ? "✅" : "🎯"} ${g.id} — ${g.text.slice(0, 120)}${g.notes.length > 0 ? ` (${g.notes.length} notes)` : ""}`);
+return { content: [{ type: "text", text: `Goals (${goals.length}):\n${lines.join("\n")}` }] };
+}
+async addGoalNoteTool(_id, params) {
+const ok = this.addNote(params.id, params.note);
+return { content: [{ type: "text", text: ok ? `Note added to ${params.id}` : `Goal ${params.id} not found` }] };
+}
 }
 export const goalManager = new GoalManager();
-//# sourceMappingURL=GoalManager.js.map

package/dist/session/MemoryStore.d.ts

@@ -19,9 +19,10 @@ export declare class MemoryStore {
     private available;
     constructor();
     get isAvailable(): boolean;
+    private lineCounts;
     save(sessionId: string, role: "user" | "assistant" | "system", content: string): void;
+    private compactFile;
     search(query: string, limit?: number): MemoryEntry[];
     buildContextBlock(sessionId: string): string;
 }
 export declare const memoryStore: MemoryStore;
-//# sourceMappingURL=MemoryStore.d.ts.map

package/dist/session/MemoryStore.js

@@ -1,92 +1,113 @@
-/**
- * MemoryStore — persistent long-term memory for agents.
- * Stored in ~/.aiaiai/memory/ as JSONL files per session.
- */
-import { existsSync, readFileSync, appendFileSync, mkdirSync, readdirSync } from "node:fs";
+
+import { existsSync, readFileSync, writeFileSync, appendFileSync, mkdirSync, readdirSync } from "node:fs";
 import { resolve } from "node:path";
 import { AgentDir } from "../core/AgentDir.js";
 export class MemoryStore {
-    basePath;
-    available = false;
-    constructor() {
-        this.basePath = resolve(AgentDir.getHome(), "memory");
-        try {
-            if (!existsSync(this.basePath))
-                mkdirSync(this.basePath, { recursive: true });
-            this.available = true;
-        }
-        catch {
-            this.available = false;
-        }
-    }
-    get isAvailable() { return this.available; }
-    save(sessionId, role, content) {
-        if (!this.available)
-            return;
-        const entry = {
-            id: `mem-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-            sessionId,
-            role,
-            content: content.slice(0, 500), // Cap individual entries
-            ts: Date.now(),
-        };
-        try {
-            appendFileSync(resolve(this.basePath, `${sessionId}.jsonl`), JSON.stringify(entry) + "\n", "utf-8");
-        }
-        catch { /* non-fatal */ }
-    }
-    search(query, limit = 8) {
-        if (!this.available)
-            return [];
-        try {
-            const all = [];
-            const files = readdirSync(this.basePath).filter((f) => f.endsWith(".jsonl"));
-            for (const file of files) {
-                const content = readFileSync(resolve(this.basePath, file), "utf-8");
-                for (const line of content.split("\n").filter(Boolean)) {
-                    try {
-                        all.push(JSON.parse(line));
-                    }
-                    catch {
-                        continue;
-                    }
-                }
-            }
-            const q = query.toLowerCase().trim();
-            const results = all.filter(e => e.content && e.content.toLowerCase().includes(q));
-            return results.sort((a, b) => b.ts - a.ts).slice(0, limit);
-        }
-        catch {
-            return [];
-        }
-    }
-    buildContextBlock(sessionId) {
-        if (!this.available)
-            return "";
-        try {
-            const path = resolve(this.basePath, `${sessionId}.jsonl`);
-            if (!existsSync(path))
-                return "";
-            const lines = readFileSync(path, "utf-8").split("\n").filter(Boolean);
-            if (lines.length < 3)
-                return "";
-            // Build a compact memory summary from previous turns
-            const entries = lines.slice(-20).map(l => { try {
-                return JSON.parse(l);
-            }
-            catch {
-                return null;
-            } }).filter(Boolean);
-            if (entries.length < 2)
-                return "";
-            const recent = entries.slice(-6);
-            const summaries = recent.map(e => `[${e.role}]: ${e.content.slice(0, 150)}`);
-            return `\n\n[RECENT MEMORY]\n${summaries.join("\n")}\n`;
-        }
-        catch {
-            return "";
-        }
-    }
+basePath;
+available = false;
+constructor() {
+this.basePath = resolve(AgentDir.getHome(), "memory");
+try {
+if (!existsSync(this.basePath))
+mkdirSync(this.basePath, { recursive: true });
+this.available = true;
+}
+catch {
+this.available = false;
+}
+}
+get isAvailable() { return this.available; }
+
+lineCounts = new Map();
+save(sessionId, role, content) {
+if (!this.available)
+return;
+const entry = {
+id: `mem-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
+sessionId,
+role,
+content: content.slice(0, 500), 
+ts: Date.now(),
+};
+try {
+appendFileSync(resolve(this.basePath, `${sessionId}.jsonl`), JSON.stringify(entry) + "\n", "utf-8");
+
+const count = (this.lineCounts.get(sessionId) ?? 0) + 1;
+this.lineCounts.set(sessionId, count);
+if (count > 200) {
+this.compactFile(sessionId);
+this.lineCounts.set(sessionId, 0);
+}
+}
+catch {  }
+}
+
+compactFile(sessionId) {
+try {
+const path = resolve(this.basePath, `${sessionId}.jsonl`);
+if (!existsSync(path))
+return;
+const content = readFileSync(path, "utf-8");
+const lines = content.split("\n").filter(Boolean);
+if (lines.length <= 200)
+return;
+
+const kept = lines.slice(-100);
+writeFileSync(path, kept.join("\n") + "\n", "utf-8");
+}
+catch {  }
+}
+search(query, limit = 8) {
+if (!this.available)
+return [];
+try {
+const all = [];
+const files = readdirSync(this.basePath).filter((f) => f.endsWith(".jsonl"));
+for (const file of files) {
+const content = readFileSync(resolve(this.basePath, file), "utf-8");
+for (const line of content.split("\n").filter(Boolean)) {
+try {
+all.push(JSON.parse(line));
+}
+catch {
+continue;
+}
+}
+}
+const q = query.toLowerCase().trim();
+const results = all.filter(e => e.content && e.content.toLowerCase().includes(q));
+return results.sort((a, b) => b.ts - a.ts).slice(0, limit);
+}
+catch {
+return [];
+}
+}
+buildContextBlock(sessionId) {
+if (!this.available)
+return "";
+try {
+const path = resolve(this.basePath, `${sessionId}.jsonl`);
+if (!existsSync(path))
+return "";
+const lines = readFileSync(path, "utf-8").split("\n").filter(Boolean);
+if (lines.length < 3)
+return "";
+
+const entries = lines.slice(-20).map(l => { try {
+return JSON.parse(l);
+}
+catch {
+return null;
+} }).filter(Boolean);
+if (entries.length < 2)
+return "";
+const recent = entries.slice(-6);
+const summaries = recent.map(e => `[${e.role}]: ${e.content.slice(0, 150)}`);
+return `\n\n[RECENT MEMORY]\n${summaries.join("\n")}\n`;
+}
+catch {
+return "";
+}
+}
 }
 export const memoryStore = new MemoryStore();
-//# sourceMappingURL=MemoryStore.js.map

package/dist/session/SessionManager.d.ts

@@ -7,10 +7,11 @@ export interface ContextPressure {
     turboReady: boolean;
 }
 export declare class SessionManager {
-    private messages;
-    private systemPrompt;
-    private maxContextTokens;
+    private head;
+    private tail;
+    private messageCount;
     private _cachedChars;
+    private systemPrompt;
     setSystemPrompt(prompt: string): void;
     getSystemPrompt(): string;
     addMessage(role: string, content: string): void;
@@ -21,5 +22,5 @@ export declare class SessionManager {
     getContextPressure(): ContextPressure;
     clearMessages(): void;
     getMessageCount(): number;
+    dispose(): void;
 }
-//# sourceMappingURL=SessionManager.d.ts.map

package/dist/session/SessionManager.js

@@ -1,63 +1,84 @@
-/**
- * SessionManager — manages conversation session state, context pressure tracking.
- */
+
+const MAX_CONTEXT_CHARS = 128_000 * 4;
+const MAX_MESSAGES = 500; 
 export class SessionManager {
-    messages = [];
-    systemPrompt = "";
-    maxContextTokens = 128_000;
-    _cachedChars = 0;
-    setSystemPrompt(prompt) {
-        this.systemPrompt = prompt;
-    }
-    getSystemPrompt() {
-        return this.systemPrompt;
-    }
-    addMessage(role, content) {
-        this.messages.push({ role, content });
-        this._cachedChars += content.length + role.length + 10;
-    }
-    getMessages() {
-        // Estimate: 1 token ≈ 4 chars
-        const maxChars = this.maxContextTokens * 4;
-        // Fast path: if total is under limit, return all
-        if (this._cachedChars <= maxChars) {
-            return [...this.messages];
-        }
-        // Slow path: walk backwards until we hit the limit
-        let total = 0;
-        const result = [];
-        for (let i = this.messages.length - 1; i >= 0; i--) {
-            const msg = this.messages[i];
-            const size = msg.content.length + msg.role.length + 10;
-            if (total + size > maxChars)
-                break;
-            total += size;
-            result.unshift(msg);
-        }
-        return result;
-    }
-    getContextPressure() {
-        const totalChars = this._cachedChars || this.messages.reduce((sum, m) => sum + m.content.length + m.role.length + 10, 0);
-        const maxChars = this.maxContextTokens * 4;
-        const pct = Math.min(100, Math.round((totalChars / maxChars) * 100));
-        let level = "green";
-        if (pct > 90)
-            level = "critical";
-        else if (pct > 75)
-            level = "red";
-        else if (pct > 50)
-            level = "yellow";
-        return {
-            pct,
-            level,
-            turboReady: pct < 70,
-        };
-    }
-    clearMessages() {
-        this.messages = [];
-    }
-    getMessageCount() {
-        return this.messages.length;
-    }
-}
-//# sourceMappingURL=SessionManager.js.map
+head = null;
+tail = null;
+messageCount = 0;
+_cachedChars = 0;
+systemPrompt = "";
+setSystemPrompt(prompt) {
+this.systemPrompt = prompt;
+}
+getSystemPrompt() {
+return this.systemPrompt;
+}
+addMessage(role, content) {
+const charSize = content.length + role.length + 10;
+const node = { role, content, charSize, next: null };
+if (this.tail) {
+this.tail.next = node;
+}
+else {
+this.head = node;
+}
+this.tail = node;
+this.messageCount++;
+this._cachedChars += charSize;
+
+while (this.messageCount > MAX_MESSAGES && this.head) {
+this._cachedChars -= this.head.charSize;
+this.head = this.head.next;
+this.messageCount--;
+}
+
+while (this._cachedChars > MAX_CONTEXT_CHARS && this.head && this.head !== this.tail) {
+this._cachedChars -= this.head.charSize;
+this.head = this.head.next;
+this.messageCount--;
+}
+}
+getMessages() {
+const result = [];
+let node = this.head;
+while (node) {
+result.push({ role: node.role, content: node.content });
+node = node.next;
+}
+return result;
+}
+getContextPressure() {
+const totalChars = this._cachedChars;
+const maxChars = 128_000 * 4;
+const pct = Math.min(100, Math.round((totalChars / maxChars) * 100));
+let level = "green";
+if (pct > 90)
+level = "critical";
+else if (pct > 75)
+level = "red";
+else if (pct > 50)
+level = "yellow";
+return {
+pct,
+level,
+turboReady: pct < 70,
+};
+}
+clearMessages() {
+this.head = null;
+this.tail = null;
+this.messageCount = 0;
+this._cachedChars = 0;
+}
+getMessageCount() {
+return this.messageCount;
+}
+
+dispose() {
+this.head = null;
+this.tail = null;
+this.messageCount = 0;
+this._cachedChars = 0;
+this.systemPrompt = "";
+}
+}

package/dist/session/SessionStore.d.ts

@@ -42,4 +42,3 @@ export declare class SessionStore {
     private generateTitle;
 }
 export declare const sessionStore: SessionStore;
-//# sourceMappingURL=SessionStore.d.ts.map