fabiana 0.1.0

package/dist/tools/safe-edit.js

@@ -0,0 +1,50 @@
+import { Type } from '@sinclair/typebox';
+import fs from 'fs/promises';
+import path from 'path';
+import { FABIANA_HOME } from '../paths.js';
+function resolve(filePath) {
+    return path.isAbsolute(filePath) ? filePath : path.join(FABIANA_HOME, filePath);
+}
+export function createSafeEditTool(validator) {
+    return {
+        name: 'safe_edit',
+        label: 'Edit File',
+        description: 'Edit a file by replacing exact text. oldText must match exactly. Paths are relative to ~/.fabiana.',
+        parameters: Type.Object({
+            path: Type.String({ description: 'File path relative to ~/.fabiana, or absolute' }),
+            oldText: Type.String({ description: 'Exact text to find and replace' }),
+            newText: Type.String({ description: 'New text to replace with' }),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { path: filePath, oldText, newText } = params;
+            const resolved = resolve(filePath);
+            if (!validator.canEdit(resolved)) {
+                return {
+                    content: [{ type: 'text', text: `❌ PERMISSION DENIED: Cannot edit ${filePath}` }],
+                    details: { error: 'permission_denied' },
+                };
+            }
+            try {
+                const content = await fs.readFile(resolved, 'utf-8');
+                if (!content.includes(oldText)) {
+                    return {
+                        content: [{ type: 'text', text: `❌ Text not found in ${filePath}. No changes made.` }],
+                        details: { error: 'text_not_found' },
+                    };
+                }
+                const updated = content.replace(oldText, newText);
+                await fs.writeFile(resolved, updated, 'utf-8');
+                return {
+                    content: [{ type: 'text', text: `✅ Edited ${filePath}` }],
+                    details: { path: filePath },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Error editing ${filePath}: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    };
+}

package/dist/tools/safe-read.js

@@ -0,0 +1,35 @@
+import { Type } from '@sinclair/typebox';
+import fs from 'fs/promises';
+import path from 'path';
+import { FABIANA_HOME } from '../paths.js';
+function resolve(filePath) {
+    return path.isAbsolute(filePath) ? filePath : path.join(FABIANA_HOME, filePath);
+}
+export function createSafeReadTool() {
+    return {
+        name: 'safe_read',
+        label: 'Read File',
+        description: 'Read the contents of any file. Paths are relative to the Fabiana home directory (~/.fabiana).',
+        parameters: Type.Object({
+            path: Type.String({ description: 'File path relative to ~/.fabiana, or absolute' }),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { path: filePath } = params;
+            const resolved = resolve(filePath);
+            try {
+                const content = await fs.readFile(resolved, 'utf-8');
+                const lines = content.split('\n').length;
+                return {
+                    content: [{ type: 'text', text: `File: ${filePath} (${lines} lines)\n\n${content}` }],
+                    details: { path: filePath, lines },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Error reading ${filePath}: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    };
+}

package/dist/tools/safe-write.js

@@ -0,0 +1,42 @@
+import { Type } from '@sinclair/typebox';
+import fs from 'fs/promises';
+import path from 'path';
+import { FABIANA_HOME } from '../paths.js';
+function resolve(filePath) {
+    return path.isAbsolute(filePath) ? filePath : path.join(FABIANA_HOME, filePath);
+}
+export function createSafeWriteTool(validator) {
+    return {
+        name: 'safe_write',
+        label: 'Write File',
+        description: 'Write content to a writable file. Creates file if it does not exist. Paths are relative to ~/.fabiana.',
+        parameters: Type.Object({
+            path: Type.String({ description: 'File path relative to ~/.fabiana, or absolute' }),
+            content: Type.String({ description: 'Content to write' }),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { path: filePath, content } = params;
+            const resolved = resolve(filePath);
+            if (!validator.canWrite(resolved)) {
+                return {
+                    content: [{ type: 'text', text: `❌ PERMISSION DENIED: Cannot write to ${filePath}` }],
+                    details: { error: 'permission_denied' },
+                };
+            }
+            try {
+                await fs.mkdir(path.dirname(resolved), { recursive: true });
+                await fs.writeFile(resolved, content, 'utf-8');
+                return {
+                    content: [{ type: 'text', text: `✅ Written to ${filePath}` }],
+                    details: { path: filePath },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Error writing ${filePath}: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    };
+}

package/dist/tools/send-message.js

@@ -0,0 +1,27 @@
+import { Type } from '@sinclair/typebox';
+export function createSendMessageTool(sendMessage) {
+    return {
+        name: 'send_message',
+        label: 'Send Message',
+        description: 'Send a message to the recipient. Use for responses and initiative messages. Supports Markdown formatting.',
+        parameters: Type.Object({
+            message: Type.String({ description: 'The message to send. Supports Markdown formatting.' }),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { message } = params;
+            try {
+                await sendMessage(message);
+                return {
+                    content: [{ type: 'text', text: `✅ Message sent` }],
+                    details: { sent: true, length: message.length },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Failed to send message: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    };
+}

package/dist/tools/send-telegram.js

@@ -0,0 +1,27 @@
+import { Type } from '@sinclair/typebox';
+export function createSendTelegramTool(sendMessage) {
+    return {
+        name: 'send_telegram',
+        label: 'Send Telegram Message',
+        description: 'Send a message to the human via Telegram. Use for responses and initiative messages.',
+        parameters: Type.Object({
+            message: Type.String({ description: 'The message to send. Supports Markdown formatting.' }),
+        }),
+        execute: async (_toolCallId, params) => {
+            const { message } = params;
+            try {
+                await sendMessage(message);
+                return {
+                    content: [{ type: 'text', text: `✅ Message sent via Telegram` }],
+                    details: { sent: true, length: message.length },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Failed to send Telegram message: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    };
+}

package/dist/tools/start-external-conversation.js

@@ -0,0 +1,86 @@
+import { Type } from '@sinclair/typebox';
+export function createStartExternalConversationTool(channels, conversationManager) {
+    return {
+        name: 'start_external_conversation',
+        label: 'Start External Conversation',
+        description: 'Initiate a DM conversation with an external person on Slack. ' +
+            'Creates the conversation state file, sends the opening message, and records the thread. ' +
+            'Only works on enabled Slack channels.',
+        parameters: Type.Object({
+            channel: Type.String({
+                description: 'Which channel adapter to use. Currently only "slack" is supported.',
+            }),
+            userId: Type.String({
+                description: 'The Slack user ID of the person to message (e.g. U0123456).',
+            }),
+            displayName: Type.String({
+                description: 'Human-readable name of the person (used in conversation records).',
+            }),
+            purpose: Type.String({
+                description: 'What this conversation is about. This is injected into the external system prompt.',
+            }),
+            message: Type.String({
+                description: 'The opening message to send.',
+            }),
+        }),
+        execute: async (_toolCallId, params) => {
+            try {
+                const adapter = channels.find((c) => c.name === params.channel);
+                if (!adapter) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `❌ Channel "${params.channel}" is not enabled. Available: ${channels.map((c) => c.name).join(', ')}`,
+                            },
+                        ],
+                        details: { error: 'channel_not_found' },
+                    };
+                }
+                const boltApp = adapter.getBoltApp?.();
+                if (!boltApp) {
+                    return {
+                        content: [{ type: 'text', text: `❌ Channel "${params.channel}" does not support start_external_conversation` }],
+                        details: { error: 'unsupported_channel' },
+                    };
+                }
+                // Open a DM channel with the user
+                const dmResult = await boltApp.client.conversations.open({ users: params.userId });
+                const channelId = dmResult.channel.id;
+                // Send the opening message
+                const msgResult = await boltApp.client.chat.postMessage({
+                    channel: channelId,
+                    text: params.message,
+                });
+                const threadId = msgResult.ts;
+                // Create conversation state file
+                const state = await conversationManager.create({
+                    channel: params.channel,
+                    externalUserId: params.userId,
+                    externalDisplayName: params.displayName,
+                    threadId,
+                    channelId,
+                    purpose: params.purpose,
+                    initiatedBy: 'owner-initiative',
+                });
+                // Record the opening message in the exchange log
+                await conversationManager.append(state.id, 'fabiana', params.message);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `✅ Conversation started with ${params.displayName} (${params.userId}).\nConversation ID: ${state.id}\nThread: ${threadId}`,
+                        },
+                    ],
+                    details: { conversationId: state.id, threadId, channelId },
+                };
+            }
+            catch (err) {
+                return {
+                    content: [{ type: 'text', text: `❌ Failed to start external conversation: ${err.message}` }],
+                    details: { error: err.message },
+                };
+            }
+        },
+    };
+}

package/dist/utils/logger.js

@@ -0,0 +1,34 @@
+import fs from 'fs/promises';
+import { paths } from '../paths.js';
+export class Logger {
+    logPath;
+    constructor(logPath) {
+        this.logPath = logPath;
+    }
+    static create() {
+        const now = new Date();
+        const month = `${now.getFullYear()}-${String(now.getMonth() + 1).padStart(2, '0')}`;
+        return new Logger(paths.logs(`${month}.log`));
+    }
+    timestamp() {
+        return new Date().toISOString();
+    }
+    async log(message) {
+        const line = `[${this.timestamp()}] INFO  ${message}\n`;
+        await fs.appendFile(this.logPath, line, 'utf-8').catch(() => { });
+    }
+    async error(message, err) {
+        const detail = err ? `: ${err.message}` : '';
+        const line = `[${this.timestamp()}] ERROR ${message}${detail}\n`;
+        await fs.appendFile(this.logPath, line, 'utf-8').catch(() => { });
+    }
+    async sessionStart(mode) {
+        const line = `\n[${this.timestamp()}] ===== SESSION START (${mode}) =====\n`;
+        await fs.appendFile(this.logPath, line, 'utf-8').catch(() => { });
+    }
+    async sessionEnd(success) {
+        const status = success ? 'OK' : 'FAILED';
+        const line = `[${this.timestamp()}] ===== SESSION END (${status}) =====\n`;
+        await fs.appendFile(this.logPath, line, 'utf-8').catch(() => { });
+    }
+}

package/dist/utils/permissions.js

@@ -0,0 +1,68 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { minimatch } from 'minimatch';
+export class PermissionValidator {
+    manifest;
+    baseDir;
+    constructor(manifest, baseDir) {
+        this.manifest = manifest;
+        this.baseDir = baseDir;
+    }
+    static async load(manifestPath) {
+        const content = await fs.readFile(manifestPath, 'utf-8');
+        const manifest = JSON.parse(content);
+        const { FABIANA_HOME } = await import('../paths.js');
+        return new PermissionValidator(manifest, FABIANA_HOME);
+    }
+    normalizePath(filePath) {
+        const absolute = path.isAbsolute(filePath)
+            ? filePath
+            : path.resolve(this.baseDir, filePath);
+        const relative = path.relative(this.baseDir, absolute);
+        if (relative.startsWith('..'))
+            throw new Error(`Path outside project: ${filePath}`);
+        return relative;
+    }
+    matchesPattern(filePath, patterns) {
+        const normalized = this.normalizePath(filePath);
+        return patterns.some(pattern => {
+            if (pattern === normalized)
+                return true;
+            if (pattern.includes('*'))
+                return minimatch(normalized, pattern, { dot: true });
+            if (pattern.endsWith('/**')) {
+                const dir = pattern.slice(0, -3);
+                return normalized === dir || normalized.startsWith(dir + '/');
+            }
+            return false;
+        });
+    }
+    canRead(_filePath) { return true; }
+    canWrite(filePath) {
+        try {
+            if (this.matchesPattern(filePath, this.manifest.permissions.readonly))
+                return false;
+            if (this.matchesPattern(filePath, this.manifest.permissions.writable))
+                return true;
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+    canEdit(filePath) { return this.canWrite(filePath); }
+    canAppend(filePath) {
+        try {
+            if (this.matchesPattern(filePath, this.manifest.permissions.readonly))
+                return false;
+            if (this.matchesPattern(filePath, this.manifest.permissions.appendonly))
+                return true;
+            if (this.matchesPattern(filePath, this.manifest.permissions.writable))
+                return true;
+            return false;
+        }
+        catch {
+            return false;
+        }
+    }
+}

package/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "fabiana",
+  "version": "0.1.0",
+  "description": "Virtual life assistant powered by pi",
+  "type": "module",
+  "bin": {
+    "fabiana": "bin/fabiana.js"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json && node scripts/build-plugins.js",
+    "prepare": "npm run build",
+    "dev": "tsx src/cli.ts start",
+    "start": "tsx src/cli.ts start",
+    "initiative": "tsx src/cli.ts initiative",
+    "consolidate": "tsx src/cli.ts consolidate",
+    "doctor": "tsx src/cli.ts doctor"
+  },
+  "files": [
+    "bin/",
+    "dist/"
+  ],
+  "keywords": [
+    "ai",
+    "agent",
+    "assistant",
+    "pi",
+    "telegram"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@inquirer/prompts": "^7.10.1",
+    "esbuild": "^0.25.0",
+    "@mariozechner/pi-ai": "latest",
+    "@mariozechner/pi-coding-agent": "latest",
+    "@mozilla/readability": "^0.6.0",
+    "@slack/bolt": "^4.6.0",
+    "chalk": "^5.6.2",
+    "commander": "^14.0.3",
+    "dotenv": "^17.3.1",
+    "linkedom": "^0.18.12",
+    "minimatch": "^10.0.0",
+    "node-cron": "^3.0.3",
+    "telegraf": "^4.16.3"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "@types/node-cron": "^3.0.11",
+    "tsx": "^4.7.0",
+    "typescript": "^5.4.0"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  }
+}