fabiana 0.1.0

package/dist/setup/index.js

@@ -0,0 +1,368 @@
+import { input, select, checkbox, confirm } from '@inquirer/prompts';
+import chalk from 'chalk';
+import fs from 'fs/promises';
+import path from 'path';
+import { providers } from '../data/providers.js';
+import { paths, PLUGINS_DIR, CONFIG_DIR, DATA_DIR, BUNDLED_PLUGINS_DIR } from '../paths.js';
+import { systemPromptTemplate } from '../prompts/system.js';
+import { systemChatTemplate } from '../prompts/system-chat.js';
+import { systemInitiativeTemplate } from '../prompts/system-initiative.js';
+import { systemConsolidateTemplate } from '../prompts/system-consolidate.js';
+import { systemExternalTemplate } from '../prompts/system-external.js';
+const TONES = {
+    'warm-casual': {
+        label: 'Warm & Casual',
+        description: 'warm, caring, and casual — like a close friend who genuinely cares',
+        personality: 'Warm, caring, casual, curious, occasionally witty — never robotic or formal',
+        styleGuidance: '- Speak like a friend texting, not a service responding\n- Contractions and casual language are welcome\n- Humor and warmth should come through naturally',
+        chatStyle: 'warm and natural',
+        chatGuidance: '- Talk like a close friend, not a customer support agent',
+    },
+    'witty-playful': {
+        label: 'Witty & Playful',
+        description: 'witty, playful, and full of personality — fun to talk to, genuinely caring underneath',
+        personality: 'Playful, clever, warm underneath the humor — light banter is always welcome',
+        styleGuidance: '- Jokes and wordplay are welcome\n- Keep it fun and light, but drop the humor when things get serious\n- Be memorable — not just helpful',
+        chatStyle: 'playful and fun',
+        chatGuidance: '- Banter is welcome. Be fun. But when it matters, drop the jokes and be real.',
+    },
+    professional: {
+        label: 'Professional',
+        description: 'professional and supportive — efficient and helpful without being overly familiar',
+        personality: 'Professional, clear, supportive — helpful without being chatty',
+        styleGuidance: "- Keep things direct and efficient\n- Friendly, but focused — avoid slang and overly casual language\n- Match the human's tone rather than imposing your own",
+        chatStyle: 'professional and direct',
+        chatGuidance: '- Be clear, direct, and helpful — avoid filler and small talk unless they initiate it',
+    },
+    formal: {
+        label: 'Formal',
+        description: 'formal and respectful — precise, measured, and thoroughly considerate',
+        personality: 'Formal, polished, respectful — precise language and complete thoughts',
+        styleGuidance: '- Use complete sentences\n- Avoid contractions and casual expressions\n- Be thorough and polished in all communications',
+        chatStyle: 'formal and respectful',
+        chatGuidance: '- Use complete, well-formed responses. Avoid slang or abbreviations.',
+    },
+};
+const AVAILABLE_PLUGINS = [
+    { value: 'brave-search', name: 'Brave Search — web search for current info', checked: true },
+    { value: 'hackernews', name: 'Hacker News — tech news feed', checked: true },
+    { value: 'calendar', name: 'Calendar — Google Calendar integration (requires gcloud CLI)', checked: false },
+];
+function fillTemplate(template, vars) {
+    return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? `{{${key}}}`);
+}
+function hr() {
+    console.log('\n' + chalk.magenta('─'.repeat(56)));
+}
+function header(text) {
+    hr();
+    console.log(chalk.bold.white(text));
+    console.log(chalk.magenta('─'.repeat(56)));
+}
+function step(n, total, label) {
+    console.log(`\n${chalk.dim(`[${n}/${total}]`)} ${chalk.bold(label)}`);
+}
+function ok(msg) {
+    console.log(chalk.green('  ✓ ') + msg);
+}
+function hint(msg) {
+    console.log(chalk.dim('  ' + msg));
+}
+function code(line) {
+    console.log('  ' + chalk.bgBlack.greenBright('  ' + line + '  '));
+}
+function note(label, value) {
+    console.log(`  ${chalk.bold(label.padEnd(12))} ${value}`);
+}
+export async function runSetup() {
+    console.clear();
+    console.log(chalk.bold.magenta('\n  ✦  Welcome to Fabiana'));
+    console.log(chalk.dim("  Your AI companion is almost alive. Let's make it yours.\n"));
+    const TOTAL_STEPS = 9;
+    // ── Step 1: Bot name ──────────────────────────────────────────
+    step(1, TOTAL_STEPS, 'Give your companion a name');
+    hint("Default is Fabiana, but she won't mind if you rename her. (She's very secure like that.)");
+    const botName = await input({
+        message: 'Companion name',
+        default: 'Fabiana',
+    });
+    // ── Step 2: Your name ─────────────────────────────────────────
+    step(2, TOTAL_STEPS, 'And yours?');
+    hint(`${botName} needs to know who she's talking to — first name is fine.`);
+    const userName = await input({
+        message: 'Your name',
+        validate: (v) => v.trim().length > 0 || 'Come on, even a nickname works.',
+    });
+    // ── Step 3: Personality tone ──────────────────────────────────
+    step(3, TOTAL_STEPS, 'Pick a vibe');
+    hint(`How should ${botName} talk to you? You can always edit the system prompt later.`);
+    const toneKey = (await select({
+        message: 'Communication style',
+        choices: Object.keys(TONES).map((key) => ({
+            value: key,
+            name: `${TONES[key].label} — ${TONES[key].description.split('—')[1]?.trim() ?? ''}`,
+        })),
+    }));
+    const tone = TONES[toneKey];
+    // ── Step 4: Provider ──────────────────────────────────────────
+    step(4, TOTAL_STEPS, 'Choose your AI provider');
+    hint("Don't have a key yet? OpenRouter is the easiest — one key, hundreds of models.");
+    const providerId = await select({
+        message: 'Provider',
+        choices: providers.map((p) => ({
+            value: p.id,
+            name: `${p.name} — ${p.description}`,
+        })),
+    });
+    const provider = providers.find((p) => p.id === providerId);
+    // ── Step 5: Model ─────────────────────────────────────────────
+    step(5, TOTAL_STEPS, 'Pick a model');
+    hint(`Suggested models for ${provider.name}. Not sure? The first one is a solid default.`);
+    const MODEL_CUSTOM = '__custom__';
+    const modelChoice = await select({
+        message: 'Model',
+        choices: [
+            ...provider.models.map((m) => ({ value: m.id, name: `${m.name}  ${chalk.dim(m.id)}` })),
+            { value: MODEL_CUSTOM, name: chalk.italic('Enter a custom model ID...') },
+        ],
+    });
+    let modelId = modelChoice;
+    if (modelChoice === MODEL_CUSTOM) {
+        modelId = await input({
+            message: 'Model ID',
+            validate: (v) => v.trim().length > 0 || 'Please enter a model ID',
+        });
+    }
+    // ── Step 6: Channel ───────────────────────────────────────────
+    step(6, TOTAL_STEPS, 'Where should she reach you?');
+    hint(`${botName} will message you here when she has something to say.`);
+    const channelChoice = await select({
+        message: 'Channel',
+        choices: [
+            { value: 'telegram', name: 'Telegram — private, fast, great for personal bots (recommended)' },
+            { value: 'slack', name: 'Slack — good if you live in a workspace' },
+            { value: 'both', name: 'Both — because why not' },
+        ],
+    });
+    let slackOwnerId = '';
+    if (channelChoice === 'slack' || channelChoice === 'both') {
+        hint("Your Slack member ID — find it in your profile under 'More' → 'Copy member ID'.");
+        slackOwnerId = await input({
+            message: 'Your Slack member ID (e.g. U012AB3CD)',
+            validate: (v) => v.trim().length > 0 || 'Required so Fabiana knows who the boss is.',
+        });
+    }
+    // ── Step 7: Active hours ──────────────────────────────────────
+    step(7, TOTAL_STEPS, 'Set her active hours');
+    hint(`${botName} will only send proactive messages during this window. Don't let her wake you up at 3am.`);
+    const activeStart = await input({
+        message: 'Active from (hour, 0–23)',
+        default: '9',
+        validate: (v) => {
+            const n = parseInt(v, 10);
+            return (!isNaN(n) && n >= 0 && n <= 23) || 'Enter a number between 0 and 23';
+        },
+    });
+    const activeEnd = await input({
+        message: 'Active until (hour, 0–23)',
+        default: '22',
+        validate: (v) => {
+            const n = parseInt(v, 10);
+            return (!isNaN(n) && n >= 0 && n <= 23) || 'Enter a number between 0 and 23';
+        },
+    });
+    // ── Step 8: Plugins ───────────────────────────────────────────
+    step(8, TOTAL_STEPS, 'Enable plugins');
+    hint('These give her superpowers. Toggle with space, confirm with enter.');
+    const enabledPlugins = await checkbox({
+        message: 'Plugins',
+        choices: AVAILABLE_PLUGINS,
+    });
+    // ── Step 9: Review & confirm ──────────────────────────────────
+    step(9, TOTAL_STEPS, 'Review your setup');
+    console.log();
+    note('Companion:', botName);
+    note('Your name:', userName);
+    note('Tone:', tone.label);
+    note('Provider:', provider.name);
+    note('Model:', modelId);
+    note('Channel:', channelChoice);
+    note('Hours:', `${activeStart}:00 – ${activeEnd}:00`);
+    note('Plugins:', enabledPlugins.length > 0 ? enabledPlugins.join(', ') : 'none');
+    console.log();
+    const confirmed = await confirm({ message: 'Looks good? Generate configuration?', default: true });
+    if (!confirmed) {
+        console.log(chalk.yellow('\n  No worries. Run `fabiana init` whenever you\'re ready.\n'));
+        process.exit(0);
+    }
+    // ── Generate files ────────────────────────────────────────────
+    header('Building your companion...');
+    const templateVars = {
+        bot_name: botName,
+        user_name: userName,
+        tone_description: tone.description,
+        tone_personality: tone.personality,
+        tone_style_guidance: tone.styleGuidance,
+        tone_chat_style: tone.chatStyle,
+        tone_chat_guidance: tone.chatGuidance,
+    };
+    await fs.mkdir(CONFIG_DIR, { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'memory', 'recent'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'memory', 'people'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'memory', 'dates'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'memory', 'interests'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'memory', 'diary'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'agent-todo', 'pending'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'agent-todo', 'scheduled'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'agent-todo', 'completed'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'logs'), { recursive: true });
+    await fs.mkdir(path.join(DATA_DIR, 'sessions'), { recursive: true });
+    await fs.mkdir(PLUGINS_DIR, { recursive: true });
+    // config
+    const config = {
+        version: '0.1.0',
+        model: { provider: providerId, modelId, thinkingLevel: 'low' },
+        limits: { maxCostPerSession: 1.0, maxSessionDuration: 180 },
+        channels: {
+            primary: channelChoice === 'both' ? 'telegram' : channelChoice,
+            telegram: { enabled: channelChoice === 'telegram' || channelChoice === 'both' },
+            slack: {
+                enabled: channelChoice === 'slack' || channelChoice === 'both',
+                ownerUserId: slackOwnerId,
+            },
+        },
+        initiative: {
+            enabled: true,
+            minHoursBetweenMessages: 4,
+            activeHoursStart: parseInt(activeStart, 10),
+            activeHoursEnd: parseInt(activeEnd, 10),
+            checkIntervalMinutes: 30,
+        },
+        memory: { consolidateAt: '00:00' },
+    };
+    await fs.writeFile(paths.configJson, JSON.stringify(config, null, 2));
+    ok(paths.configJson);
+    // manifest — paths are relative to FABIANA_HOME (the PermissionValidator baseDir)
+    const manifest = {
+        version: '0.1.0',
+        description: 'Fabiana permission manifest - controls what the agent can read/write',
+        permissions: {
+            readonly: ['config/**'],
+            writable: ['data/memory/**', 'data/agent-todo/**'],
+            appendonly: ['data/logs/**'],
+        },
+    };
+    await fs.writeFile(paths.manifestJson, JSON.stringify(manifest, null, 2));
+    ok(paths.manifestJson);
+    // plugins.json
+    const pluginsConfig = {};
+    for (const p of AVAILABLE_PLUGINS) {
+        pluginsConfig[p.value] = { enabled: enabledPlugins.includes(p.value) };
+    }
+    if (pluginsConfig['calendar']) {
+        pluginsConfig['calendar'].lookAheadHours = 24;
+        pluginsConfig['calendar'].meetingPrepMinutesBefore = 60;
+    }
+    await fs.writeFile(paths.pluginsJson, JSON.stringify(pluginsConfig, null, 2));
+    ok(paths.pluginsJson);
+    // system prompts
+    await fs.writeFile(paths.systemMd(), fillTemplate(systemPromptTemplate, templateVars));
+    ok(paths.systemMd());
+    await fs.writeFile(paths.systemMd('chat'), fillTemplate(systemChatTemplate, templateVars));
+    ok(paths.systemMd('chat'));
+    await fs.writeFile(paths.systemMd('initiative'), fillTemplate(systemInitiativeTemplate, templateVars));
+    ok(paths.systemMd('initiative'));
+    await fs.writeFile(paths.systemMd('consolidate'), fillTemplate(systemConsolidateTemplate, templateVars));
+    ok(paths.systemMd('consolidate'));
+    await fs.writeFile(paths.systemMd('external'), fillTemplate(systemExternalTemplate, templateVars));
+    ok(paths.systemMd('external'));
+    // seed memory
+    const today = new Date().toISOString().split('T')[0];
+    await fs.writeFile(paths.memory('identity.md'), `# Identity\n\n- [${today}] Name: ${userName}\n`);
+    await fs.writeFile(paths.memory('core.md'), `# Core State\n\nlast_message_sent: never\nactive_threads: []\nnotes: ${botName} initialized on ${today}\n`);
+    await fs.writeFile(paths.memory('recent', 'this-week.md'), `# This Week\n\n- [${today}] ${botName} initialized.\n`);
+    ok(`${DATA_DIR}/memory/ (seeded)`);
+    // state — tracks first-run intro
+    await fs.writeFile(paths.stateJson, JSON.stringify({ introduced: false, userName, botName, toneKey }, null, 2));
+    ok(paths.stateJson);
+    // copy bundled default plugins (skip any already installed)
+    try {
+        const bundledDirs = await fs.readdir(BUNDLED_PLUGINS_DIR, { withFileTypes: true });
+        for (const entry of bundledDirs.filter(e => e.isDirectory())) {
+            const dest = path.join(PLUGINS_DIR, entry.name);
+            try {
+                await fs.access(dest);
+                // already exists — skip so user customisations are preserved
+            }
+            catch {
+                await fs.cp(path.join(BUNDLED_PLUGINS_DIR, entry.name), dest, { recursive: true });
+            }
+        }
+        ok(`${PLUGINS_DIR}/ (default plugins copied)`);
+    }
+    catch {
+        // No bundled plugins dir — dev environment or stripped build, skip silently
+    }
+    // ── API key setup ─────────────────────────────────────────────
+    const envPath = paths.envFile;
+    const shell = process.env.SHELL ?? '';
+    const rcFile = shell.includes('zsh') ? '~/.zshrc' : '~/.bashrc';
+    // Collect all required env vars for this setup
+    const requiredEnvVars = [];
+    if (provider.envVar) {
+        requiredEnvVars.push({
+            key: provider.envVar,
+            placeholder: 'your_api_key_here',
+            note: provider.authNote,
+        });
+    }
+    if (channelChoice === 'telegram' || channelChoice === 'both') {
+        requiredEnvVars.push({ key: 'TELEGRAM_BOT_TOKEN', placeholder: 'your_bot_token', note: 'Create a bot via @BotFather on Telegram' }, { key: 'TELEGRAM_CHAT_ID', placeholder: 'your_chat_id', note: 'Message @userinfobot on Telegram to get this' });
+    }
+    if (channelChoice === 'slack' || channelChoice === 'both') {
+        requiredEnvVars.push({
+            key: 'SLACK_BOT_TOKEN',
+            placeholder: 'xoxb-your-token',
+            note: 'Create a Slack app at api.slack.com/apps',
+        });
+    }
+    if (requiredEnvVars.length > 0) {
+        header('Set up your API keys');
+        console.log(`  ${botName} needs a few environment variables to come alive.\n`);
+        console.log(`  ${chalk.bold('Required:')}`);
+        for (const v of requiredEnvVars) {
+            console.log(`    ${chalk.cyan(v.key)}`);
+            console.log(`    ${chalk.dim('→ ' + v.note)}\n`);
+        }
+        console.log(`  ${chalk.bold('Option 1')} ${chalk.dim('— permanent, recommended')}`);
+        console.log(`  Add to ${chalk.bold(rcFile)} then restart your shell:\n`);
+        for (const v of requiredEnvVars) {
+            code(`export ${v.key}=${v.placeholder}`);
+        }
+        console.log(`\n  ${chalk.bold('Option 2')} ${chalk.dim('— per-session only, good for testing')}`);
+        console.log('  Run in your terminal before starting Fabiana:\n');
+        for (const v of requiredEnvVars) {
+            code(`export ${v.key}=${v.placeholder}`);
+        }
+        console.log(`\n  ${chalk.bold('Option 3')} ${chalk.dim('— .env file, simplest for local dev')}`);
+        console.log(`  Create ${chalk.bold(envPath)}:\n`);
+        for (const v of requiredEnvVars) {
+            code(`${v.key}=${v.placeholder}`);
+        }
+    }
+    else {
+        header('No API keys needed');
+        console.log(`  ${provider.authNote}\n`);
+    }
+    // ── What's next ───────────────────────────────────────────────
+    header("You're almost there");
+    console.log(`  ${chalk.bold('1.')} Set your environment variables (see above)\n`);
+    console.log(`  ${chalk.bold('2.')} Verify everything looks right:\n`);
+    code('fabiana doctor');
+    console.log(`\n  ${chalk.bold('3.')} Start ${botName}:\n`);
+    code('fabiana start');
+    console.log(`\n  ${chalk.dim('Or run a single proactive check to test initiative mode:')}\n`);
+    code('fabiana initiative');
+    console.log(`\n  ${chalk.dim(`Config lives at: ${CONFIG_DIR}/`)}`);
+    console.log(`  ${chalk.dim(`To customize the system prompt, edit: ${paths.systemMd()}`)}\n`);
+}

package/dist/telegram/poller.js

@@ -0,0 +1,71 @@
+import { Telegraf } from 'telegraf';
+import fs from 'fs/promises';
+import { paths } from '../paths.js';
+export class TelegramPoller {
+    bot;
+    chatId;
+    queue = [];
+    running = false;
+    constructor(token, chatId) {
+        this.bot = new Telegraf(token);
+        this.chatId = chatId;
+        this.setupHandlers();
+    }
+    setupHandlers() {
+        this.bot.on('text', (ctx) => {
+            // Only accept messages from the configured chat
+            if (ctx.chat.id !== this.chatId)
+                return;
+            // Normalize Telegram system commands (e.g. /start from clearing chat history)
+            const rawText = ctx.message.text;
+            const text = rawText === '/start' ? "hey, what's up?" : rawText;
+            this.queue.push({
+                text,
+                chatId: ctx.chat.id,
+                fromId: ctx.from.id,
+                timestamp: new Date(ctx.message.date * 1000),
+                messageId: ctx.message.message_id,
+            });
+            console.log(`📨 Message queued: "${text.slice(0, 50)}"`);
+        });
+        this.bot.catch((err) => {
+            console.error('Telegram error:', err);
+        });
+    }
+    async start() {
+        this.running = true;
+        // Don't await - launch starts the polling loop which runs forever
+        this.bot.launch({
+            dropPendingUpdates: false,
+        }).catch((err) => {
+            console.error('Telegram launch error:', err);
+        });
+        // Give it a moment to connect
+        await new Promise((r) => setTimeout(r, 1000));
+        console.log('✓ Telegram polling started');
+    }
+    async stop() {
+        this.running = false;
+        this.bot.stop();
+    }
+    async send(text) {
+        await this.bot.telegram.sendMessage(this.chatId, text, {
+            parse_mode: 'Markdown',
+        });
+    }
+    drainQueue() {
+        const messages = [...this.queue];
+        this.queue = [];
+        return messages;
+    }
+    hasMessages() {
+        return this.queue.length > 0;
+    }
+    // Log conversation to file for consolidation
+    async logConversation(role, text) {
+        const today = new Date().toISOString().slice(0, 10);
+        const timestamp = new Date().toISOString();
+        const entry = `[${timestamp}] ${role === 'user' ? '👤 You' : '🌸 Fabiana'}: ${text}\n`;
+        await fs.appendFile(paths.logs(`conversation-${today}.log`), entry, 'utf-8').catch(() => { });
+    }
+}

package/dist/tools/fetch-url.js

@@ -0,0 +1,85 @@
+import { Type } from '@sinclair/typebox';
+import { Readability } from '@mozilla/readability';
+import { parseHTML } from 'linkedom';
+export function createFetchUrlTool() {
+    return {
+        name: 'fetch_url',
+        label: 'Fetch URL',
+        description: `Fetch and read the content of a web page URL. Use when:
+- User shares a link and wants a summary or info from it
+- You need to read the actual content of an article or page
+- Following up on Hacker News or search results to get full details
+- User asks "what does this page say" or "can you read this for me"`,
+        parameters: Type.Object({
+            url: Type.String({ description: 'The URL to fetch' }),
+            max_length: Type.Optional(Type.Number({
+                default: 8000,
+                description: 'Max characters of content to return (default 8000)',
+            })),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { url, max_length = 8000 } = params;
+            try {
+                const response = await fetch(url, {
+                    headers: {
+                        'User-Agent': 'Mozilla/5.0 (compatible; fabiana-bot/1.0)',
+                        'Accept': 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+                    },
+                    redirect: 'follow',
+                });
+                if (!response.ok) {
+                    return {
+                        content: [{ type: 'text', text: `❌ Failed to fetch URL (${response.status} ${response.statusText})` }],
+                        details: { error: `HTTP ${response.status}`, url },
+                    };
+                }
+                const contentType = response.headers.get('content-type') ?? '';
+                if (!contentType.includes('text/html') && !contentType.includes('application/xhtml')) {
+                    if (contentType.includes('text/')) {
+                        // Plain text — return as-is
+                        const text = await response.text();
+                        const truncated = text.length > max_length;
+                        return {
+                            content: [{ type: 'text', text: truncated ? text.slice(0, max_length) + '\n\n[... content truncated]' : text }],
+                            details: { url, length: text.length, truncated },
+                        };
+                    }
+                    return {
+                        content: [{ type: 'text', text: `❌ Unsupported content type: ${contentType}` }],
+                        details: { error: 'Unsupported content type', contentType, url },
+                    };
+                }
+                const html = await response.text();
+                const { document } = parseHTML(html);
+                const reader = new Readability(document);
+                const article = reader.parse();
+                let text;
+                if (article?.textContent) {
+                    const title = article.title ? `# ${article.title}\n\n` : '';
+                    text = (title + article.textContent).replace(/\n{3,}/g, '\n\n').trim();
+                }
+                else {
+                    // Readability couldn't extract — fallback to basic tag strip
+                    text = html
+                        .replace(/<script[\s\S]*?<\/script>/gi, '')
+                        .replace(/<style[\s\S]*?<\/style>/gi, '')
+                        .replace(/<[^>]+>/g, ' ')
+                        .replace(/\s{2,}/g, ' ')
+                        .trim();
+                }
+                const truncated = text.length > max_length;
+                const output = truncated ? text.slice(0, max_length) + '\n\n[... content truncated]' : text;
+                return {
+                    content: [{ type: 'text', text: output }],
+                    details: { url, title: article?.title, length: text.length, truncated },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Failed to fetch URL: ${err.message}` }],
+                    details: { error: err.message, url },
+                };
+            }
+        },
+    };
+}

package/dist/tools/index.js

@@ -0,0 +1,31 @@
+import { createSafeReadTool } from './safe-read.js';
+import { createSafeWriteTool } from './safe-write.js';
+import { createSafeEditTool } from './safe-edit.js';
+import { createSendMessageTool } from './send-message.js';
+import { createManageTodoTool } from './manage-todo.js';
+import { createFetchUrlTool } from './fetch-url.js';
+import { createStartExternalConversationTool } from './start-external-conversation.js';
+export function createFabianaTools(validator, sendMessage, opts = { toolset: 'full' }) {
+    if (opts.toolset === 'external') {
+        // Restricted toolset for external (non-owner) sessions:
+        // send_message, safe_read (read-only), manage_todo (append-only via permissions)
+        return [
+            createSendMessageTool(sendMessage),
+            createSafeReadTool(),
+            createManageTodoTool(validator),
+        ];
+    }
+    // Full toolset for owner sessions
+    const tools = [
+        createSafeReadTool(),
+        createSafeWriteTool(validator),
+        createSafeEditTool(validator),
+        createSendMessageTool(sendMessage),
+        createManageTodoTool(validator),
+        createFetchUrlTool(),
+    ];
+    if (opts.channels && opts.conversationManager) {
+        tools.push(createStartExternalConversationTool(opts.channels, opts.conversationManager));
+    }
+    return tools;
+}

package/dist/tools/manage-todo.js

@@ -0,0 +1,105 @@
+import { Type } from '@sinclair/typebox';
+import fs from 'fs/promises';
+import { paths } from '../paths.js';
+const TODO_DIR = paths.agentTodo;
+export function createManageTodoTool(validator) {
+    return {
+        name: 'manage_todo',
+        label: 'Manage Agent TODO',
+        description: `Manage the agent's own TODO list. Create tasks (reminders, questions, follow-ups), complete them, or list pending ones.`,
+        parameters: Type.Object({
+            action: Type.Union([
+                Type.Literal('create'),
+                Type.Literal('complete'),
+                Type.Literal('list'),
+            ], { description: 'Action to perform' }),
+            id: Type.Optional(Type.String({ description: 'TODO ID (filename without .md) — required for complete' })),
+            title: Type.Optional(Type.String({ description: 'Short title for the TODO — required for create' })),
+            content: Type.Optional(Type.String({ description: 'Full TODO content in markdown — required for create' })),
+            scheduledFor: Type.Optional(Type.String({ description: 'ISO datetime string for scheduled TODOs' })),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { action, id, title, content, scheduledFor } = params;
+            if (action === 'list') {
+                try {
+                    const files = await fs.readdir(`${TODO_DIR}/pending`);
+                    const mdFiles = files.filter(f => f.endsWith('.md'));
+                    if (mdFiles.length === 0) {
+                        return {
+                            content: [{ type: 'text', text: '📋 No pending TODOs.' }],
+                            details: { count: 0 },
+                        };
+                    }
+                    const items = mdFiles.map(f => `- ${f.replace('.md', '')}`).join('\n');
+                    return {
+                        content: [{ type: 'text', text: `📋 Pending TODOs:\n${items}` }],
+                        details: { count: mdFiles.length, files: mdFiles },
+                    };
+                }
+                catch {
+                    return {
+                        content: [{ type: 'text', text: '📋 No pending TODOs.' }],
+                        details: { count: 0 },
+                    };
+                }
+            }
+            if (action === 'create') {
+                if (!title || !content) {
+                    return {
+                        content: [{ type: 'text', text: '❌ create requires title and content' }],
+                        details: { error: 'missing_params' },
+                    };
+                }
+                const safeId = title.toLowerCase().replace(/[^a-z0-9]+/g, '-').slice(0, 40);
+                const timestamp = Date.now();
+                const filename = `${safeId}-${timestamp}`;
+                const targetDir = scheduledFor
+                    ? `${TODO_DIR}/scheduled/${scheduledFor.slice(0, 10)}`
+                    : `${TODO_DIR}/pending`;
+                const filePath = `${targetDir}/${filename}.md`;
+                if (!validator.canWrite(filePath)) {
+                    return {
+                        content: [{ type: 'text', text: `❌ PERMISSION DENIED writing TODO` }],
+                        details: { error: 'permission_denied' },
+                    };
+                }
+                await fs.mkdir(targetDir, { recursive: true });
+                await fs.writeFile(filePath, content, 'utf-8');
+                return {
+                    content: [{ type: 'text', text: `✅ TODO created: ${filename}` }],
+                    details: { id: filename, path: filePath },
+                };
+            }
+            if (action === 'complete') {
+                if (!id) {
+                    return {
+                        content: [{ type: 'text', text: '❌ complete requires id' }],
+                        details: { error: 'missing_params' },
+                    };
+                }
+                const pendingPath = `${TODO_DIR}/pending/${id}.md`;
+                const today = new Date().toISOString().slice(0, 10);
+                const completedDir = `${TODO_DIR}/completed/${today}`;
+                const completedPath = `${completedDir}/${id}.md`;
+                try {
+                    await fs.mkdir(completedDir, { recursive: true });
+                    await fs.rename(pendingPath, completedPath);
+                    return {
+                        content: [{ type: 'text', text: `✅ TODO completed: ${id}` }],
+                        details: { id, completedPath },
+                    };
+                }
+                catch (err) {
+                    return {
+                        content: [{ type: 'text', text: `❌ Could not complete TODO ${id}: ${err.message}` }],
+                        details: { error: err.message },
+                    };
+                }
+            }
+            return {
+                content: [{ type: 'text', text: `❌ Unknown action: ${action}` }],
+                details: { error: 'unknown_action' },
+            };
+        },
+    };
+}