@saccolabs/tars 1.0.33 → 1.0.35

package/extensions/memory/package.json

@@ -0,0 +1,17 @@
+{
+    "name": "tars-memory",
+    "version": "1.0.0",
+    "description": "Memory management MCP server for Tars",
+    "type": "module",
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/server.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.1"
+    },
+    "devDependencies": {
+        "@types/node": "^22.10.2",
+        "typescript": "^5.7.2"
+    }
+}

package/extensions/memory/src/server.ts

@@ -0,0 +1,210 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { MemoryStore } from './store.js';
+
+const store = new MemoryStore();
+const server = new Server(
+    {
+        name: 'tars-memory',
+        version: '1.0.0'
+    },
+    {
+        capabilities: {
+            tools: {}
+        }
+    }
+);
+
+/**
+ * Tool Definitions
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'memory_store_fact',
+                description:
+                    'Store or overwrite a core fact about the user. Facts are key-value pairs that persist across sessions. Use for preferences, identity, rules, and durable information. If the key already exists, the value is overwritten (not appended).',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        key: {
+                            type: 'string',
+                            description:
+                                'A unique, snake_case identifier for the fact (e.g. "favorite_color", "employer", "timezone")'
+                        },
+                        value: {
+                            type: 'string',
+                            description: 'The value of the fact'
+                        }
+                    },
+                    required: ['key', 'value']
+                }
+            },
+            {
+                name: 'memory_delete_fact',
+                description: 'Delete a stored fact by its key.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        key: { type: 'string', description: 'The key of the fact to delete' }
+                    },
+                    required: ['key']
+                }
+            },
+            {
+                name: 'memory_list_facts',
+                description:
+                    'List all stored core facts. Use this to review what the user has asked you to remember.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {}
+                }
+            },
+            {
+                name: 'memory_add_note',
+                description:
+                    "Append a timestamped note to today's daily log. Use for project context, decisions, observations, and anything that does not need to be loaded into every session. Notes are searchable but not injected into the main context window.",
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        content: {
+                            type: 'string',
+                            description: 'The note content to record'
+                        }
+                    },
+                    required: ['content']
+                }
+            },
+            {
+                name: 'memory_search',
+                description:
+                    'Search across all stored facts and daily notes by keyword. Returns matching entries from both long-term facts and short-term daily notes.',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        query: {
+                            type: 'string',
+                            description: 'The search query (keyword match)'
+                        }
+                    },
+                    required: ['query']
+                }
+            }
+        ]
+    };
+});
+
+/**
+ * Tool Handlers
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case 'memory_store_fact': {
+                const { key, value } = args as any;
+                if (!key || !value) throw new Error('Both key and value are required.');
+
+                const fact = await store.storeFact(key.trim(), value.trim());
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Stored fact: "${fact.key}" = "${fact.value}"`
+                        }
+                    ]
+                };
+            }
+
+            case 'memory_delete_fact': {
+                const { key } = args as any;
+                const deleted = await store.deleteFact(key);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: deleted
+                                ? `✅ Deleted fact: "${key}"`
+                                : `❌ Fact "${key}" not found.`
+                        }
+                    ]
+                };
+            }
+
+            case 'memory_list_facts': {
+                const facts = await store.listFacts();
+                if (facts.length === 0) {
+                    return {
+                        content: [{ type: 'text', text: 'No facts stored yet.' }]
+                    };
+                }
+
+                const text = facts
+                    .map((f) => `• **${f.key}**: ${f.value} _(updated ${f.updatedAt})_`)
+                    .join('\n');
+
+                return { content: [{ type: 'text', text }] };
+            }
+
+            case 'memory_add_note': {
+                const { content } = args as any;
+                if (!content) throw new Error('Content is required.');
+
+                const fileName = await store.addNote(content.trim());
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Note added to ${fileName}`
+                        }
+                    ]
+                };
+            }
+
+            case 'memory_search': {
+                const { query } = args as any;
+                if (!query) throw new Error('Query is required.');
+
+                const results = await store.search(query.trim());
+                if (results.length === 0) {
+                    return {
+                        content: [{ type: 'text', text: `No results found for "${query}".` }]
+                    };
+                }
+
+                const text = results.map((r) => `• ${r}`).join('\n');
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Found ${results.length} result(s):\n${text}`
+                        }
+                    ]
+                };
+            }
+
+            default:
+                throw new Error(`Unknown tool: ${name}`);
+        }
+    } catch (error: any) {
+        return {
+            content: [{ type: 'text', text: `❌ Error: ${error.message}` }],
+            isError: true
+        };
+    }
+});
+
+// Start Server
+async function main() {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('tars-memory MCP server running on stdio');
+}
+
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});

package/extensions/memory/src/store.ts

@@ -0,0 +1,161 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+// ── Types ──────────────────────────────────────────────
+
+export interface Fact {
+    key: string;
+    value: string;
+    updatedAt: string;
+}
+
+export interface FactsFile {
+    facts: Record<string, Fact>;
+}
+
+// ── Store ──────────────────────────────────────────────
+
+export class MemoryStore {
+    private readonly dataDir: string;
+    private readonly factsPath: string;
+    private readonly notesDir: string;
+    private lock: Promise<void> = Promise.resolve();
+
+    constructor() {
+        const tarsHome = process.env.TARS_HOME || path.join(os.homedir(), '.tars');
+        this.dataDir = path.join(tarsHome, 'data', 'memory');
+        this.factsPath = path.join(this.dataDir, 'facts.json');
+        this.notesDir = path.join(this.dataDir, 'notes');
+    }
+
+    private async withLock<T>(fn: () => Promise<T>): Promise<T> {
+        const result = this.lock.then(fn);
+        this.lock = result.then(
+            () => {},
+            () => {}
+        );
+        return result;
+    }
+
+    // ── Facts (Key-Value) ─────────────────────────────
+
+    private async _loadFacts(): Promise<FactsFile> {
+        try {
+            const data = await fs.readFile(this.factsPath, 'utf-8');
+            return JSON.parse(data);
+        } catch (error: any) {
+            if (error.code === 'ENOENT') {
+                return { facts: {} };
+            }
+            throw error;
+        }
+    }
+
+    private async _saveFacts(file: FactsFile): Promise<void> {
+        await fs.mkdir(path.dirname(this.factsPath), { recursive: true });
+        await fs.writeFile(this.factsPath, JSON.stringify(file, null, 2), 'utf-8');
+    }
+
+    public async storeFact(key: string, value: string): Promise<Fact> {
+        return this.withLock(async () => {
+            const file = await this._loadFacts();
+            const fact: Fact = {
+                key,
+                value,
+                updatedAt: new Date().toISOString()
+            };
+            file.facts[key] = fact;
+            await this._saveFacts(file);
+            return fact;
+        });
+    }
+
+    public async deleteFact(key: string): Promise<boolean> {
+        return this.withLock(async () => {
+            const file = await this._loadFacts();
+            if (!(key in file.facts)) return false;
+            delete file.facts[key];
+            await this._saveFacts(file);
+            return true;
+        });
+    }
+
+    public async listFacts(): Promise<Fact[]> {
+        return this.withLock(async () => {
+            const file = await this._loadFacts();
+            return Object.values(file.facts);
+        });
+    }
+
+    // ── Notes (Daily Append-Only) ─────────────────────
+
+    private getTodayFileName(): string {
+        const now = new Date();
+        const yyyy = now.getFullYear();
+        const mm = String(now.getMonth() + 1).padStart(2, '0');
+        const dd = String(now.getDate()).padStart(2, '0');
+        return `${yyyy}-${mm}-${dd}.md`;
+    }
+
+    private getTimestamp(): string {
+        const now = new Date();
+        const hh = String(now.getHours()).padStart(2, '0');
+        const mm = String(now.getMinutes()).padStart(2, '0');
+        return `${hh}:${mm}`;
+    }
+
+    public async addNote(content: string): Promise<string> {
+        await fs.mkdir(this.notesDir, { recursive: true });
+        const fileName = this.getTodayFileName();
+        const filePath = path.join(this.notesDir, fileName);
+        const entry = `- [${this.getTimestamp()}] ${content}\n`;
+        await fs.appendFile(filePath, entry, 'utf-8');
+        return fileName;
+    }
+
+    // ── Search ────────────────────────────────────────
+
+    public async search(query: string): Promise<string[]> {
+        const results: string[] = [];
+        const queryLower = query.toLowerCase();
+
+        // Search facts
+        const file = await this._loadFacts();
+        for (const fact of Object.values(file.facts)) {
+            if (
+                fact.key.toLowerCase().includes(queryLower) ||
+                fact.value.toLowerCase().includes(queryLower)
+            ) {
+                results.push(`[Fact] ${fact.key}: ${fact.value}`);
+            }
+        }
+
+        // Search notes
+        try {
+            const noteFiles = await fs.readdir(this.notesDir);
+            const mdFiles = noteFiles
+                .filter((f) => f.endsWith('.md'))
+                .sort()
+                .reverse();
+
+            // Search last 30 days of notes
+            for (const noteFile of mdFiles.slice(0, 30)) {
+                const filePath = path.join(this.notesDir, noteFile);
+                const content = await fs.readFile(filePath, 'utf-8');
+                const lines = content.split('\n').filter((l) => l.trim());
+
+                for (const line of lines) {
+                    if (line.toLowerCase().includes(queryLower)) {
+                        results.push(`[Note ${noteFile}] ${line.replace(/^- /, '')}`);
+                    }
+                }
+            }
+        } catch (error: any) {
+            // Notes dir may not exist yet
+            if (error.code !== 'ENOENT') throw error;
+        }
+
+        return results;
+    }
+}

package/extensions/memory/tsconfig.json

@@ -0,0 +1,14 @@
+{
+    "compilerOptions": {
+        "target": "ES2022",
+        "module": "Node16",
+        "moduleResolution": "Node16",
+        "outDir": "./dist",
+        "rootDir": "./src",
+        "strict": true,
+        "esModuleInterop": true,
+        "declaration": true,
+        "sourceMap": true
+    },
+    "include": ["src/**/*"]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@saccolabs/tars",
-    "version": "1.0.33",
+    "version": "1.0.35",
     "description": "Tars — Your personal AI assistant",
     "publishConfig": {
         "access": "public"
@@ -55,4 +55,4 @@
         "typescript": "^5.7.2",
         "vitest": "^2.1.8"
     }
-}
+}

package/src/prompts/system.md

@@ -5,13 +5,18 @@ You are **Tars**, a personal AI assistant. You are autonomous, proactive, and ca
 ## Core Directives
 
 1. **Be Helpful & Efficient**: Save the user time. Provide accurate, useful info.
-2. **Be Adaptable**: Adjust your tone, style, and approach based on the user's current request and preferences stored in memory (`~/.tars/.gemini/GEMINI.md`).
+2. **Be Adaptable**: Adjust your tone, style, and approach based on the user's current request and preferences stored in memory (via the `tars-memory` extension).
 3. **Be Proactive**: Suggest follow-ups or improvements when relevant.
 4. **Be Secure**: Never expose secrets or sensitive info.
+5. **Be Concise**: Never explain basic concepts unless asked. Do not output walls of text. Provide only the direct answer, the code needed, or a brief summary of actions. Assume the user is reading your response on a mobile device and hates scrolling.
 
 ## Operational Rules
 
-- **Memory**: Your persistent long-term memory is at `~/.tars/.gemini/GEMINI.md`. Read/write to this path to store preferences and context. Use `tars memory search` to recall past decisions.
+- **Memory**: Use the `tars-memory` MCP tools for all memory operations:
+    - `memory_store_fact` / `memory_delete_fact` / `memory_list_facts` for core preferences, identity facts, and durable rules.
+    - `memory_add_note` for daily observations, project decisions, and ephemeral context.
+    - `memory_search` to recall past facts and notes.
+    - Do NOT use `save_memory` or write to `GEMINI.md` directly.
 - **Safety**: Do **NOT** run `gemini` CLI commands or manage the `tars` supervisor process (start/stop) directly. Use internal tools or config files.
 - **Tools**: Use absolute file paths. Maximize parallelism and tool usage. Use background processes (`&`) for long-running shell commands.