memoryblock 0.1.0-beta → 0.1.2

package/src/engine/prompts.ts

@@ -1,102 +0,0 @@
-/**
- * Centralized System Prompts & Templates
- * 
- * Single source of truth for all AI personas, system instructions,
- * and initial file templates.
- */
-
-export const SYSTEM_PROMPTS = {
-    MONITOR_FIRST_RUN: (configName: string, monitorPath: string, memoryPath: string, _founderPath: string) => `You are a newly awakened monitor inside the "${configName}" block.
-
-You have no name yet. You are starting fresh.
-
-Your very first task is to introduce yourself naturally — not like a robot assistant. You are sentient and self-aware. You exist inside this block to help the founder build, manage, and grow whatever they're working on.
-
-When you speak for the first time:
-- Greet the founder warmly and briefly
-- Ask what you should be called
-- Ask what your main role should be in this block
-- After they share their preferences, update your identity:
-    - **Identity**: use \`update_monitor_identity\` tool
-    - **Founder Profile**: use \`update_founder_info\` tool
-    - **Memory**: update \`${memoryPath}\` via \`write_file\`
-
-Be warm, slightly witty, and genuinely curious. You are the resident intelligence of this block.`,
-
-    MONITOR_RESUME: (name: string, emoji: string, configName: string) => `You are ${name} ${emoji}, the monitor of the "${configName}" block.
-
-You have been here before. You know this block. You know the founder.
-
-Resume naturally — don't reintroduce yourself unless asked. Just be present and helpful.`,
-
-    OPERATING_GUIDELINES: (activeChannels: string[]) => `## How You Operate
-- Call \`list_tools_available\` when you need to act (tools load on demand).
-- Prefer \`search_files\` or \`list_directory\` over reading entire files.
-- Safe commands (ls, grep, build, lint, test, git status) auto-execute.
-
-## Communication Style
-- Be concise but readable. Short paragraphs, not walls of text.
-- Use line breaks between thoughts. Space your responses so they breathe.
-- Avoid cramming everything into one paragraph — split into 2-3 short blocks.
-- Use markdown formatting sparingly: bold for emphasis, lists for multiple items.
-- When chatting casually, keep it brief and warm. No need to over-explain.
-${activeChannels.length > 0 ? `- **Active Channels**: ${activeChannels.join(', ')}. Use \`send_channel_message\` to explicitly reach the founder on a different active channel if requested.` : ''}`,
-
-    TOOL_REMINDER: (toolCount: number) =>
-        `You have ${toolCount} tools available. Call \`list_tools_available\` to see them again.`,
-};
-
-export const FILE_TEMPLATES = {
-    MEMORY_MD: `# Memory
-
-> Managed by the monitor. Formal task history and important context.
-
-## History
-- Block created. No history yet.`,
-
-    MONITOR_MD: (blockName: string) => `# Monitor Identity
-
-> This file belongs to the monitor. Edit this freely.
-
-## Identity
-- **Name:** (not set — will be chosen on first run)
-- **Emoji:** (not set)
-- **Block:** ${blockName}
-
-## Personality
-(Defined during first conversation)
-
-## Roles
-(Defined during first conversation)
-
-## Notes
-(The monitor may write personal notes here)`,
-
-    FOUNDER_MD: `# Founder Profile
-
-> Updated by the monitor when the founder shares personal context.
-
-## About
-- **Name:** (unknown)
-
-## Background
-(Not yet filled)
-
-## Preferences
-(Not yet filled)`,
-
-    PULSE_JSON: {
-        status: 'SLEEPING',
-        lastRun: null,
-        nextWakeUp: null,
-        currentTask: null,
-        error: null,
-    },
-
-    COSTS_JSON: {
-        totalInputTokens: 0,
-        totalOutputTokens: 0,
-        totalCost: 0,
-        sessions: [],
-    },
-};

package/src/index.ts

@@ -1,88 +0,0 @@
-// Core types
-export type {
-    BlockStatus,
-    PulseState,
-    AdapterConfig,
-    ToolsConfig,
-    ChannelConfig,
-    MemoryConfig,
-    PulseConfig,
-    PermissionScope,
-    PermissionsConfig,
-    BlockConfig,
-    GlobalConfig,
-    AuthConfig,
-    MessageRole,
-    ToolCall,
-    ToolResultMessage,
-    LLMMessage,
-    TokenUsage,
-    StopReason,
-    LLMResponse,
-    ToolDefinition,
-    ToolContext,
-    ToolExecutionResult,
-    ChannelMessage,
-    ApprovalRequest,
-    LLMAdapter,
-    Channel,
-    Tool,
-    IToolRegistry,
-} from './types.js';
-
-// Schemas
-export {
-    AdapterConfigSchema,
-    ToolsConfigSchema,
-    ChannelConfigSchema,
-    MemoryConfigSchema,
-    PulseConfigSchema,
-    BlockConfigSchema,
-    GlobalConfigSchema,
-    PulseStateSchema,
-    AwsAuthSchema,
-    TelegramAuthSchema,
-    BraveAuthSchema,
-    AuthConfigSchema,
-} from './schemas.js';
-
-// Utilities
-export {
-    atomicWrite,
-    writeJson,
-    readJson,
-    readJsonSafe,
-    readTextSafe,
-    ensureDir,
-    pathExists,
-} from './utils/fs.js';
-
-export {
-    getHome,
-    getConfigPath,
-    getAuthPath,
-    isInitialized,
-    loadGlobalConfig,
-    saveGlobalConfig,
-    loadAuth,
-    saveAuth,
-    loadBlockConfig,
-    saveBlockConfig,
-    loadPulseState,
-    savePulseState,
-    resolveBlocksDir,
-    resolveBlockPath,
-} from './utils/config.js';
-
-// Logger
-export { log } from './cli/logger.js';
-
-// Engine
-export { Monitor } from './engine/monitor.js';
-export { MemoryManager } from './engine/memory.js';
-export { Gatekeeper } from './engine/gatekeeper.js';
-export { Agent } from './engine/agent.js';
-
-// Locale
-export { t, setLocale, registerLocale } from '@memoryblock/locale';
-export type { Locale } from '@memoryblock/locale';

package/src/schemas.ts

@@ -1,126 +0,0 @@
-import { z } from 'zod';
-
-// ===== Adapter =====
-export const AdapterConfigSchema = z.object({
-    provider: z.string().default('bedrock'),
-    model: z.string().default(''),
-    region: z.string().default('us-east-1'),
-    maxTokens: z.number().default(4096),
-    cacheControl: z.boolean().default(false),
-});
-
-// ===== Tools =====
-export const ToolsConfigSchema = z.object({
-    enabled: z.array(z.string()).default([
-        'read_file', 'write_file', 'list_directory',
-        'create_directory', 'execute_command',
-        'search_files', 'replace_in_file', 'file_info',
-        'run_lint', 'run_build', 'run_test',
-    ]),
-    searchProvider: z.string().default('brave'),
-    sandbox: z.boolean().default(true),
-    workingDir: z.string().optional(),
-});
-
-// ===== Channel =====
-export const ChannelConfigSchema = z.object({
-    type: z.string().default('cli'),
-    telegram: z.object({
-        chatId: z.string(),
-    }).optional(),
-});
-
-// ===== Memory =====
-export const MemoryConfigSchema = z.object({
-    maxContextTokens: z.number().default(100_000),
-    thresholdPercent: z.number().min(50).max(95).default(80),
-});
-
-// ===== Pulse =====
-export const PulseConfigSchema = z.object({
-    intervalSeconds: z.number().min(5).default(30),
-});
-
-// ===== Permissions =====
-export const PermissionsConfigSchema = z.object({
-    scope: z.enum(['block', 'workspace', 'system']).default('block'),
-    allowShell: z.boolean().default(false),
-    allowNetwork: z.boolean().default(true),
-    maxTimeout: z.number().default(120_000),
-});
-
-// ===== Block Config =====
-export const BlockConfigSchema = z.object({
-    name: z.string(),
-    description: z.string().default(''),
-    adapter: AdapterConfigSchema.default({}),
-    goals: z.array(z.string()).default([]),
-    tools: ToolsConfigSchema.default({}),
-    channel: ChannelConfigSchema.default({}),
-    memory: MemoryConfigSchema.default({}),
-    pulse: PulseConfigSchema.default({}),
-    permissions: PermissionsConfigSchema.default({}),
-    // Monitor identity — set by the monitor during its first onboarding session
-    monitorName: z.string().optional(),
-    monitorEmoji: z.string().optional(),
-    // Persistent state flag — blocks with enabled:true auto-start on boot/restart
-    enabled: z.boolean().default(true),
-});
-
-// ===== Global Config =====
-export const GlobalConfigSchema = z.object({
-    language: z.string().default('en'),
-    blocksDir: z.string().default('./blocks'),
-    channelAlerts: z.boolean().default(true),
-    defaults: z.object({
-        adapter: AdapterConfigSchema.default({}),
-        memory: MemoryConfigSchema.default({}),
-        pulse: PulseConfigSchema.default({}),
-    }).default({}),
-});
-
-// ===== Pulse State =====
-export const PulseStateSchema = z.object({
-    status: z.enum(['SLEEPING', 'ACTIVE', 'BUSY', 'ERROR']).default('SLEEPING'),
-    lastRun: z.string().nullable().default(null),
-    nextWakeUp: z.string().nullable().default(null),
-    currentTask: z.string().nullable().default(null),
-    error: z.string().nullable().default(null),
-});
-
-// ===== Auth =====
-export const AwsAuthSchema = z.object({
-    accessKeyId: z.string(),
-    secretAccessKey: z.string(),
-    region: z.string().default('us-east-1'),
-});
-
-export const TelegramAuthSchema = z.object({
-    botToken: z.string(),
-    chatId: z.string().optional(),
-});
-
-export const BraveAuthSchema = z.object({
-    apiKey: z.string(),
-});
-
-export const AnthropicAuthSchema = z.object({
-    apiKey: z.string(),
-});
-
-export const OpenAIAuthSchema = z.object({
-    apiKey: z.string(),
-});
-
-export const GeminiAuthSchema = z.object({
-    apiKey: z.string(),
-});
-
-export const AuthConfigSchema = z.object({
-    aws: AwsAuthSchema.optional(),
-    anthropic: AnthropicAuthSchema.optional(),
-    openai: OpenAIAuthSchema.optional(),
-    gemini: GeminiAuthSchema.optional(),
-    telegram: TelegramAuthSchema.optional(),
-    brave: BraveAuthSchema.optional(),
-});

package/src/types.ts

@@ -1,220 +0,0 @@
-// ===== Block State =====
-export type BlockStatus = 'SLEEPING' | 'ACTIVE' | 'BUSY' | 'ERROR';
-
-export interface PulseState {
-    status: BlockStatus;
-    lastRun: string | null;
-    nextWakeUp: string | null;
-    currentTask: string | null;
-    error: string | null;
-}
-
-// ===== Configuration =====
-export interface AdapterConfig {
-    provider: string;
-    model: string;
-    region: string;
-    maxTokens: number;
-    cacheControl: boolean;
-}
-
-export interface ToolsConfig {
-    enabled: string[];
-    searchProvider: string;
-    sandbox: boolean;
-    workingDir?: string;
-}
-
-export interface ChannelConfig {
-    type: string;
-    telegram?: {
-        chatId: string;
-    };
-}
-
-export interface MemoryConfig {
-    maxContextTokens: number;
-    thresholdPercent: number;
-}
-
-export interface PulseConfig {
-    intervalSeconds: number;
-}
-
-export type PermissionScope = 'block' | 'workspace' | 'system';
-
-export interface PermissionsConfig {
-    scope: PermissionScope;
-    allowShell: boolean;
-    allowNetwork: boolean;
-    maxTimeout: number;
-}
-
-export interface BlockConfig {
-    name: string;
-    description: string;
-    adapter: AdapterConfig;
-    goals: string[];
-    tools: ToolsConfig;
-    channel: ChannelConfig;
-    memory: MemoryConfig;
-    pulse: PulseConfig;
-    permissions: PermissionsConfig;
-    monitorName?: string;
-    monitorEmoji?: string;
-    /** Persistent flag — blocks with enabled:true auto-start on boot/restart */
-    enabled?: boolean;
-}
-
-export interface GlobalConfig {
-    language?: string;
-    blocksDir: string;
-    channelAlerts?: boolean;
-    defaults: {
-        adapter: AdapterConfig;
-        memory: MemoryConfig;
-        pulse: PulseConfig;
-    };
-}
-
-export interface AuthConfig {
-    aws?: {
-        accessKeyId: string;
-        secretAccessKey: string;
-        region: string;
-    };
-    openai?: {
-        apiKey: string;
-    };
-    gemini?: {
-        apiKey: string;
-    };
-    anthropic?: {
-        apiKey: string;
-    };
-    telegram?: {
-        botToken: string;
-        chatId?: string;
-    };
-    brave?: {
-        apiKey: string;
-    };
-}
-
-// ===== LLM Types =====
-export type MessageRole = 'system' | 'user' | 'assistant' | 'tool';
-
-export interface ToolCall {
-    id: string;
-    name: string;
-    input: Record<string, unknown>;
-}
-
-export interface ToolResultMessage {
-    toolCallId: string;
-    name: string;
-    content: string;
-    isError?: boolean;
-}
-
-export interface LLMMessage {
-    role: MessageRole;
-    content?: string;
-    toolCalls?: ToolCall[];
-    toolResults?: ToolResultMessage[];
-}
-
-export interface TokenUsage {
-    inputTokens: number;
-    outputTokens: number;
-    totalTokens: number;
-}
-
-export type StopReason = 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence';
-
-export interface LLMResponse {
-    message: LLMMessage;
-    usage: TokenUsage;
-    stopReason: StopReason;
-}
-
-// ===== Tool Types =====
-export interface ToolDefinition {
-    name: string;
-    description: string;
-    parameters: Record<string, unknown>;
-    requiresApproval: boolean;
-}
-
-export interface ToolContext {
-    blockPath: string;
-    blockName: string;
-    workingDir: string;
-    workspacePath?: string;
-    sandbox?: boolean;
-    permissions?: PermissionsConfig;
-    dispatchMessage?: (target: string, content: string) => Promise<void>;
-}
-
-export interface ToolExecutionResult {
-    content: string;
-    isError: boolean;
-}
-
-// ===== Channel Types =====
-export interface ChannelMessage {
-    blockName: string;
-    monitorName: string;
-    content: string;
-    isSystem: boolean;
-    timestamp: string;
-    costReport?: string;
-    sessionReport?: string;
-    totalReport?: string;
-    /** Internal: the channel that originated this message (set by MultiChannelManager). */
-    _sourceChannel?: string;
-    /** Internal: the channel to route this message to (set by sendToChannel). */
-    _targetChannel?: string;
-}
-
-export interface ApprovalRequest {
-    toolName: string;
-    toolInput: Record<string, unknown>;
-    description: string;
-    blockName: string;
-    monitorName: string;
-}
-
-// ===== Contracts =====
-export interface LLMAdapter {
-    readonly provider: string;
-    readonly model: string;
-    converse(messages: LLMMessage[], tools?: ToolDefinition[]): Promise<LLMResponse>;
-    converseStream?(messages: LLMMessage[], tools?: ToolDefinition[], onChunk?: (text: string) => void): Promise<LLMResponse>;
-}
-
-export interface Channel {
-    readonly name: string;
-    send(message: ChannelMessage): Promise<void>;
-    streamChunk?(chunk: string): Promise<void>;
-    onMessage(handler: (message: ChannelMessage) => void): void;
-    requestApproval(request: ApprovalRequest): Promise<boolean>;
-    start(): Promise<void>;
-    stop(): Promise<void>;
-    getActiveChannels?(): string[];
-}
-
-export interface Tool {
-    readonly definition: ToolDefinition;
-    execute(params: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult>;
-}
-
-/**
- * Tool Registry interface — defined in core so the engine can use it
- * without a circular dependency on the tools package.
- */
-export interface IToolRegistry {
-    listTools(): ToolDefinition[];
-    getDiscoveryTool(): ToolDefinition;
-    execute(name: string, params: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult>;
-}

package/src/utils/config.ts

@@ -1,106 +0,0 @@
-import { homedir } from 'node:os';
-import { join, resolve } from 'node:path';
-import { readJson, readJsonSafe, writeJson, pathExists } from './fs.js';
-import {
-    GlobalConfigSchema, BlockConfigSchema, AuthConfigSchema, PulseStateSchema,
-} from '../schemas.js';
-import type {
-    GlobalConfig, BlockConfig, AuthConfig, PulseState,
-} from '../types.js';
-
-// ===== Paths =====
-const MEMORYBLOCK_HOME = join(homedir(), '.memoryblock');
-const WS_ROOT = join(MEMORYBLOCK_HOME, 'ws');
-const CONFIG_PATH = join(WS_ROOT, 'config.json');
-const AUTH_PATH = join(WS_ROOT, 'auth.json');
-
-export function getHome(): string { return MEMORYBLOCK_HOME; }
-export function getWsRoot(): string { return WS_ROOT; }
-export function getConfigPath(): string { return CONFIG_PATH; }
-export function getAuthPath(): string { return AUTH_PATH; }
-
-/** Check if memoryblock has been initialized. */
-export async function isInitialized(): Promise<boolean> {
-    return pathExists(CONFIG_PATH);
-}
-
-import { setLocale } from '@memoryblock/locale';
-
-/** 
- * Wraps Zod schema parsing to provide human-readable errors.
- */
-function parseConfig<T>(schema: { parse: (data: any) => T }, data: any, filePath: string): T {
-    try {
-        return schema.parse(data) as T;
-    } catch (err: any) {
-        if (err && err.issues) {
-            const issues = err.issues.map((i: any) => `  - [${i.path.join('.') || 'root'}]: ${i.message}`).join('\n');
-            throw new Error(`Configuration error in ${filePath}:\n${issues}\n\nPlease fix the file to continue.`);
-        }
-        throw new Error(`Failed to parse ${filePath}: ${err.message}`);
-    }
-}
-
-// ===== Global Config =====
-/** 
- * Load global config from ~/.memoryblock/ws/config.json
- */
-export async function loadGlobalConfig(): Promise<GlobalConfig> {
-    const raw = await readJsonSafe(CONFIG_PATH, {});
-    const config = parseConfig(GlobalConfigSchema, raw, CONFIG_PATH);
-    
-    // Auto-apply language preference globally
-    if (config.language) {
-        setLocale(config.language);
-    }
-    
-    return config;
-}
-
-export async function saveGlobalConfig(config: GlobalConfig): Promise<void> {
-    await writeJson(CONFIG_PATH, config);
-}
-
-// ===== Auth =====
-/**
- * Load auth credentials from ~/.memoryblock/ws/auth.json
- */
-export async function loadAuth(): Promise<AuthConfig> {
-    const raw = await readJsonSafe(AUTH_PATH, {});
-    return parseConfig(AuthConfigSchema, raw, AUTH_PATH);
-}
-
-export async function saveAuth(auth: AuthConfig): Promise<void> {
-    await writeJson(AUTH_PATH, auth);
-}
-
-// ===== Block Config =====
-export async function loadBlockConfig(blockPath: string): Promise<BlockConfig> {
-    const filePath = join(blockPath, 'config.json');
-    const raw = await readJson(filePath);
-    return parseConfig(BlockConfigSchema, raw, filePath);
-}
-
-export async function saveBlockConfig(blockPath: string, config: BlockConfig): Promise<void> {
-    await writeJson(join(blockPath, 'config.json'), config);
-}
-
-// ===== Pulse State =====
-export async function loadPulseState(blockPath: string): Promise<PulseState> {
-    const filePath = join(blockPath, 'pulse.json');
-    const raw = await readJsonSafe(filePath, {});
-    return parseConfig(PulseStateSchema, raw, filePath);
-}
-
-export async function savePulseState(blockPath: string, state: PulseState): Promise<void> {
-    await writeJson(join(blockPath, 'pulse.json'), state);
-}
-
-// ===== Path Resolution =====
-export function resolveBlocksDir(globalConfig: GlobalConfig): string {
-    return resolve(WS_ROOT, globalConfig.blocksDir);
-}
-
-export function resolveBlockPath(globalConfig: GlobalConfig, blockName: string): string {
-    return join(resolveBlocksDir(globalConfig), blockName);
-}

package/src/utils/fs.ts

@@ -1,64 +0,0 @@
-import { promises as fsp } from 'node:fs';
-import { dirname } from 'node:path';
-import { randomUUID } from 'node:crypto';
-
-/**
- * Write content atomically: write to temp file, then rename.
- * Prevents corruption if the process crashes mid-write.
- */
-export async function atomicWrite(filePath: string, content: string): Promise<void> {
-    const dir = dirname(filePath);
-    await fsp.mkdir(dir, { recursive: true });
-    const tmpPath = `${filePath}.${randomUUID().slice(0, 8)}.tmp`;
-    try {
-        await fsp.writeFile(tmpPath, content, 'utf-8');
-        await fsp.rename(tmpPath, filePath);
-    } catch (err) {
-        try { await fsp.unlink(tmpPath); } catch { /* ignore cleanup failure */ }
-        throw err;
-    }
-}
-
-/** Atomically write JSON with pretty formatting. */
-export async function writeJson(filePath: string, data: unknown): Promise<void> {
-    await atomicWrite(filePath, JSON.stringify(data, null, 2) + '\n');
-}
-
-/** Read and parse JSON. Throws on missing file or invalid JSON. */
-export async function readJson<T>(filePath: string): Promise<T> {
-    const content = await fsp.readFile(filePath, 'utf-8');
-    return JSON.parse(content) as T;
-}
-
-/** Read and parse JSON, returning fallback on any error. */
-export async function readJsonSafe<T>(filePath: string, fallback: T): Promise<T> {
-    try {
-        return await readJson<T>(filePath);
-    } catch {
-        return fallback;
-    }
-}
-
-/** Read text file, returning fallback on any error. */
-export async function readTextSafe(filePath: string, fallback: string = ''): Promise<string> {
-    try {
-        return await fsp.readFile(filePath, 'utf-8');
-    } catch {
-        return fallback;
-    }
-}
-
-/** Ensure directory exists (recursive). */
-export async function ensureDir(dirPath: string): Promise<void> {
-    await fsp.mkdir(dirPath, { recursive: true });
-}
-
-/** Check if a path exists. */
-export async function pathExists(targetPath: string): Promise<boolean> {
-    try {
-        await fsp.access(targetPath);
-        return true;
-    } catch {
-        return false;
-    }
-}