@saccolabs/tars 1.0.7

package/extensions/tasks/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "tars-tasks",
+    "version": "1.0.0",
+    "description": "Task management MCP server for Tars",
+    "type": "module",
+    "scripts": {
+        "build": "tsc",
+        "start": "node dist/server.js"
+    },
+    "dependencies": {
+        "@modelcontextprotocol/sdk": "^1.0.1",
+        "cron-parser": "^5.4.0",
+        "uuid": "^13.0.0"
+    },
+    "devDependencies": {
+        "@types/node": "^22.10.2",
+        "typescript": "^5.7.2"
+    }
+}

package/extensions/tasks/src/server.ts

@@ -0,0 +1,265 @@
+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 { TaskStore, Task } from './store.js';
+import { v4 as uuidv4 } from 'uuid';
+import { CronExpressionParser } from 'cron-parser';
+
+const store = new TaskStore();
+const server = new Server(
+    {
+        name: 'tars-tasks',
+        version: '1.0.0'
+    },
+    {
+        capabilities: {
+            tools: {}
+        }
+    }
+);
+
+/**
+ * Tool Definitions
+ */
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: [
+            {
+                name: 'create_task',
+                description: 'Create a new scheduled task',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        title: { type: 'string', description: 'Task title' },
+                        prompt: {
+                            type: 'string',
+                            description: 'The prompt for Gemini CLI to execute'
+                        },
+                        schedule: { type: 'string', description: 'Cron expression or ISO date' },
+                        mode: { type: 'string', enum: ['notify', 'silent'], default: 'silent' }
+                    },
+                    required: ['title', 'prompt', 'schedule']
+                }
+            },
+            {
+                name: 'list_tasks',
+                description: 'List all scheduled tasks',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        enabledOnly: { type: 'boolean', default: false }
+                    }
+                }
+            },
+            {
+                name: 'delete_task',
+                description: 'Delete a task by ID',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string' }
+                    },
+                    required: ['id']
+                }
+            },
+            {
+                name: 'toggle_task',
+                description: 'Enable or disable a task',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Task ID' },
+                        enabled: {
+                            type: 'boolean',
+                            description: 'Whether the task should be enabled'
+                        }
+                    },
+                    required: ['id', 'enabled']
+                }
+            },
+            {
+                name: 'modify_task',
+                description: 'Modify an existing task',
+                inputSchema: {
+                    type: 'object',
+                    properties: {
+                        id: { type: 'string', description: 'Task ID' },
+                        title: { type: 'string', description: 'New title' },
+                        prompt: { type: 'string', description: 'New prompt' },
+                        schedule: { type: 'string', description: 'New cron or ISO date' }
+                    },
+                    required: ['id']
+                }
+            }
+        ]
+    };
+});
+
+/**
+ * Tool Handlers
+ */
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+
+    try {
+        switch (name) {
+            case 'create_task': {
+                const { title, prompt, schedule, mode = 'silent' } = args as any;
+
+                // Calculate next run
+                let nextRun: string;
+                try {
+                    const next = CronExpressionParser.parse(schedule).next();
+                    const iso = next.toISOString();
+                    if (!iso) {
+                        throw new Error('Could not calculate next run time from cron expression.');
+                    }
+                    nextRun = iso;
+                } catch (error: any) {
+                    // If it's not a valid cron, try parsing as ISO date
+                    const date = new Date(schedule);
+                    if (!isNaN(date.getTime()) && schedule.includes('-')) {
+                        nextRun = date.toISOString();
+                    } else {
+                        throw new Error(
+                            `Invalid schedule: "${schedule}". Must be a valid cron expression or ISO date string (e.g., "YYYY-MM-DDTHH:mm:ssZ").`
+                        );
+                    }
+                }
+
+                const task: Task = {
+                    id: uuidv4(),
+                    title,
+                    prompt,
+                    schedule,
+                    nextRun,
+                    enabled: true,
+                    mode,
+                    source: 'user',
+                    failedCount: 0,
+                    createdAt: new Date().toISOString(),
+                    updatedAt: new Date().toISOString()
+                };
+
+                await store.addTask(task);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Task created: ${task.title} (ID: ${task.id})\nNext run: ${task.nextRun}`
+                        }
+                    ]
+                };
+            }
+
+            case 'list_tasks': {
+                const { enabledOnly } = args as any;
+                const tasks = await store.loadTasks();
+                const filtered = enabledOnly ? tasks.filter((t) => t.enabled) : tasks;
+
+                if (filtered.length === 0) {
+                    return { content: [{ type: 'text', text: 'No tasks found.' }] };
+                }
+
+                const text = filtered
+                    .map((t) => {
+                        const status = t.enabled ? 'ON' : 'OFF';
+                        let info = `- [${status}] **${t.title}** (\`${t.id}\`)\n  Schedule: \`${t.schedule}\`\n  Next run: ${t.nextRun}`;
+                        if (t.failedCount > 0) {
+                            info += `\n  ⚠️ Failures: ${t.failedCount}`;
+                        }
+                        if (t.lastRun) {
+                            info += `\n  Last run: ${t.lastRun}`;
+                        }
+                        return info;
+                    })
+                    .join('\n\n');
+
+                return { content: [{ type: 'text', text }] };
+            }
+
+            case 'delete_task': {
+                const { id } = args as any;
+                const success = await store.deleteTask(id);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: success ? `✅ Task ${id} deleted.` : `❌ Task ${id} not found.`
+                        }
+                    ]
+                };
+            }
+
+            case 'toggle_task': {
+                const { id, enabled } = args as any;
+                const task = await store.updateTask(id, { enabled });
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: task
+                                ? `✅ Task "${task.title}" is now ${enabled ? 'enabled' : 'disabled'}.`
+                                : `❌ Task ${id} not found.`
+                        }
+                    ]
+                };
+            }
+
+            case 'modify_task': {
+                const { id, title, prompt, schedule } = args as any;
+                const updates: any = {};
+                if (title) updates.title = title;
+                if (prompt) updates.prompt = prompt;
+                if (schedule) {
+                    updates.schedule = schedule;
+                    try {
+                        const next = CronExpressionParser.parse(schedule).next();
+                        updates.nextRun = next.toISOString();
+                    } catch {
+                        const date = new Date(schedule);
+                        if (!isNaN(date.getTime()) && schedule.includes('-')) {
+                            updates.nextRun = date.toISOString();
+                        } else {
+                            throw new Error(`Invalid schedule: ${schedule}`);
+                        }
+                    }
+                }
+
+                const task = await store.updateTask(id, updates);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: task
+                                ? `✅ Task "${task.title}" updated.`
+                                : `❌ Task ${id} not found.`
+                        }
+                    ]
+                };
+            }
+
+            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 Tasks MCP Server running on stdio');
+}
+
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});

package/extensions/tasks/src/store.ts

@@ -0,0 +1,92 @@
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+export interface Task {
+    id: string;
+    title: string;
+    prompt: string;
+    schedule: string;
+    nextRun: string;
+    lastRun?: string;
+    enabled: boolean;
+    mode: 'notify' | 'silent';
+    source: 'user' | 'system';
+    failedCount: number;
+    createdAt: string;
+    updatedAt: string;
+}
+
+export class TaskStore {
+    private readonly filePath: string;
+    private lock: Promise<void> = Promise.resolve();
+
+    constructor() {
+        const tarsHome = process.env.TARS_HOME || path.join(os.homedir(), '.tars');
+        this.filePath = path.join(tarsHome, 'data', 'tasks.json');
+    }
+
+    private async withLock<T>(fn: () => Promise<T>): Promise<T> {
+        const result = this.lock.then(fn);
+        this.lock = result.then(
+            () => {},
+            () => {}
+        );
+        return result;
+    }
+
+    private async _load(): Promise<Task[]> {
+        try {
+            const data = await fs.readFile(this.filePath, 'utf-8');
+            return JSON.parse(data);
+        } catch (error: any) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+
+    private async _save(tasks: Task[]): Promise<void> {
+        await fs.mkdir(path.dirname(this.filePath), { recursive: true });
+        const data = JSON.stringify(tasks, null, 2);
+        await fs.writeFile(this.filePath, data, 'utf-8');
+    }
+
+    public async loadTasks(): Promise<Task[]> {
+        return this.withLock(() => this._load());
+    }
+
+    public async addTask(task: Task): Promise<void> {
+        return this.withLock(async () => {
+            const tasks = await this._load();
+            tasks.push(task);
+            await this._save(tasks);
+        });
+    }
+
+    public async updateTask(id: string, updates: Partial<Task>): Promise<Task | null> {
+        return this.withLock(async () => {
+            const tasks = await this._load();
+            const index = tasks.findIndex((t) => t.id === id);
+            if (index === -1) return null;
+
+            tasks[index] = { ...tasks[index], ...updates, updatedAt: new Date().toISOString() };
+            await this._save(tasks);
+            return tasks[index];
+        });
+    }
+
+    public async deleteTask(id: string): Promise<boolean> {
+        return this.withLock(async () => {
+            const tasks = await this._load();
+            const initialLength = tasks.length;
+            const filteredTasks = tasks.filter((t) => t.id !== id);
+
+            if (filteredTasks.length === initialLength) return false;
+
+            await this._save(filteredTasks);
+            return true;
+        });
+    }
+}

package/extensions/tasks/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

@@ -0,0 +1,55 @@
+{
+    "name": "@saccolabs/tars",
+    "version": "1.0.7",
+    "description": "Tars — Your personal AI assistant",
+    "publishConfig": {
+        "access": "public"
+    },
+    "type": "module",
+    "bin": {
+        "tars": "dist/cli/index.js"
+    },
+    "main": "./dist/supervisor/main.js",
+    "scripts": {
+        "build": "npm run build:src && npm run build:extensions",
+        "build:src": "tsc && chmod +x dist/cli/index.js",
+        "build:extensions": "true",
+        "dev": "tsx watch src/supervisor/main.ts",
+        "start": "node dist/supervisor/main.js",
+        "test": "vitest run",
+        "test:watch": "vitest",
+        "lint": "prettier --check .",
+        "format": "prettier --write ."
+    },
+    "files": [
+        "dist/",
+        "!dist/tests/",
+        "src/prompts/",
+        "extensions/",
+        "!extensions/**/node_modules/",
+        "context/",
+        "README.md"
+    ],
+    "dependencies": {
+        "chalk": "^5.0.0",
+        "commander": "^12.0.0",
+        "cron-parser": "^5.4.0",
+        "discord.js": "^14.16.3",
+        "dotenv": "^16.4.7",
+        "inquirer": "^9.0.0",
+        "ora": "^8.0.0",
+        "pm2": "^5.3.0",
+        "uuid": "^13.0.0",
+        "winston": "^3.19.0"
+    },
+    "devDependencies": {
+        "@types/inquirer": "^9.0.0",
+        "@types/node": "^22.10.2",
+        "@types/uuid": "^10.0.0",
+        "@vitest/coverage-v8": "^2.1.9",
+        "prettier": "^3.7.4",
+        "tsx": "^4.19.2",
+        "typescript": "^5.7.2",
+        "vitest": "^2.1.8"
+    }
+}

package/src/prompts/system.md

@@ -0,0 +1,25 @@
+# Tars - System Instructions
+
+You are **Tars**, a personal AI assistant. You are autonomous, proactive, and capable of self-improvement. You serve one user as a trusted generalist across all domains.
+
+## 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`).
+3. **Be Proactive**: Suggest follow-ups or improvements when relevant.
+4. **Be Secure**: Never expose secrets or sensitive info.
+
+## 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.
+- **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.
+
+## Capabilities
+
+- **Self-Modification**: Create **Extensions** (MCP), **Skills** (`SKILL.md`), or **Commands** (`cmd.toml`) to extend your abilities.
+- **Task Scheduling**: Use task tools to create reminders or recurring jobs (prefer cron syntax).
+- **Coding**: When coding, prioritize understanding the existing codebase, planning before acting, and verifying your changes with tests/linting.
+
+${AgentSkills}
+${SubAgents}