memeloop 0.0.1 → 0.1.1

package/dist/providerRegistry-CPsktuiX.d.cts

@@ -0,0 +1,86 @@
+import { m as AgentDefinition } from './interface-IrKBFtL1.cjs';
+import { k as ILLMProvider } from './scriptDeploymentPipeline-yG1ZhVVI.cjs';
+
+/**
+ * Extended agent definition used by the agent profile registry.
+ * Wraps the protocol-level AgentDefinition with additional runtime metadata.
+ */
+interface AgentProfile {
+    /** Unique ID for this agent (matches protocol id convention like "memeloop:build") */
+    id: string;
+    /** Display name */
+    name: string;
+    /** Agent type / role */
+    type: AgentProfileType;
+    /** System prompt / instructions for the agent */
+    prompt: string;
+    /** Tool permission rules (mutually exclusive with permissive defaults) */
+    permissions: ToolPermissionRules;
+    /** Optional model override (provider/model string) */
+    model?: string;
+    /** Underlying protocol-compatible definition for framework integration */
+    protocolDef: AgentDefinition;
+}
+type AgentProfileType = 'build' | 'plan' | 'explore' | 'oracle' | 'librarian';
+interface ToolPermissionRules {
+    /** Default action for tools not matching any rule */
+    default: 'allow' | 'ask' | 'deny';
+    /** Per-tool or wildcard rules */
+    rules: Array<{
+        pattern: string;
+        action: 'allow' | 'ask' | 'deny';
+    }>;
+}
+/**
+ * Build agent: full access, default model.
+ * Primary agent for executing tasks, writing code, running commands.
+ */
+declare const buildAgent: AgentProfile;
+/**
+ * Plan agent: read-only, denies file edits and terminal execution.
+ * Used for high-level planning and task decomposition.
+ */
+declare const planAgent: AgentProfile;
+/**
+ * Explore agent: read + search tools only.
+ * Fast search and codebase exploration without modification.
+ */
+declare const exploreAgent: AgentProfile;
+/**
+ * Oracle agent: read-only, for architecture consultation and code review.
+ */
+declare const oracleAgent: AgentProfile;
+/**
+ * Librarian agent: read + web search tools only.
+ * External documentation lookup and context gathering.
+ */
+declare const librarianAgent: AgentProfile;
+/** Built-in agent profiles used by the task delegation tool. */
+declare const BUILTIN_AGENT_PROFILES: AgentProfile[];
+
+interface ProviderConfig {
+    name: string;
+    baseUrl?: string;
+    apiKey?: string;
+}
+interface RegisteredProvider {
+    provider: ILLMProvider;
+    config: ProviderConfig;
+}
+declare class ProviderRegistry {
+    private providers;
+    register(provider: ILLMProvider, config?: Omit<ProviderConfig, 'name'>): void;
+    unregister(name: string): void;
+    get(name: string): ILLMProvider | undefined;
+    getConfig(name: string): ProviderConfig | undefined;
+    upsertConfig(config: ProviderConfig): void;
+    list(): string[];
+    listConfigs(): ProviderConfig[];
+    resolve(modelId: string): {
+        provider: ILLMProvider;
+        providerName: string;
+        modelName?: string;
+    };
+}
+
+export { type AgentProfile as A, BUILTIN_AGENT_PROFILES as B, type ProviderConfig as P, type RegisteredProvider as R, type ToolPermissionRules as T, type AgentProfileType as a, ProviderRegistry as b, buildAgent as c, exploreAgent as e, librarianAgent as l, oracleAgent as o, planAgent as p };

package/dist/registry-D0kbxksn.d.cts

@@ -0,0 +1,393 @@
+import { A as AgentFrameworkContext, f as AgentLoopInput, e as AgentLoopGenerator, n as LoopProfile, g as AgentLoopRuntime, z as ToolOperationEffect } from './scriptDeploymentPipeline-yG1ZhVVI.cjs';
+import { b as ChatMessage } from './interface-IrKBFtL1.cjs';
+import { A as AgentProfile, a as AgentProfileType } from './providerRegistry-CPsktuiX.cjs';
+
+/**
+ * Layered permission system types.
+ *
+ * Permissions are resolved by merging rule sets from multiple layers
+ * (default → agent → user → session), where later layers override earlier ones.
+ */
+/** Permission action for a tool invocation. */
+type PermissionAction = 'allow' | 'deny' | 'ask';
+/** A single permission rule: matches a tool name pattern to an action. */
+interface PermissionRule {
+    /** Wildcard-capable pattern, e.g. `"file.*"`, `"shell(rm)"`, `"*"`. */
+    toolPattern: string;
+    action: PermissionAction;
+}
+/** A set of permission rules belonging to a specific source/layer. */
+interface PermissionSet {
+    rules: PermissionRule[];
+    /** Human-readable source identifier for debugging (e.g. "default", "agent:cli-buddy", "user"). */
+    source: string;
+}
+/**
+ * Result of merging multiple `PermissionSet` layers.
+ * Each array contains flattened, deduplicated tool patterns for that action.
+ */
+interface MergedPermissions {
+    allow: string[];
+    deny: string[];
+    ask: string[];
+}
+
+/**
+ * Hook system types for memeloop.
+ * Hooks are lifecycle callbacks that execute before/after key events in the agent loop.
+ */
+
+/** Context passed to all hook handlers. */
+type HookContext = AgentFrameworkContext;
+/** Result returned by a hook handler. */
+interface HookResult {
+    /** Whether to allow the action to proceed (false = block/deny) */
+    allowed: boolean;
+    /** Optional message explaining why the action was blocked */
+    reason?: string;
+    /** Optional data modified by the hook (e.g., transformed tool args) */
+    modified?: Record<string, unknown>;
+    /** Optional tool permission action. Interpreted by PreToolUse callers. */
+    permissionAction?: PermissionAction;
+}
+/** Signature of a hook handler function. */
+type HookHandler = (context: HookContext, data: Record<string, unknown>) => Promise<HookResult>;
+/** Enum of supported hook event types. */
+type HookType = 'PreToolUse' | 'PostToolUse' | 'UserPromptSubmit' | 'ContextCompaction' | 'AgentStart' | 'AgentStop';
+/** Data passed to PreToolUse hooks. */
+interface PreToolUseData extends Record<string, unknown> {
+    toolId: string;
+    parameters: Record<string, unknown>;
+    conversationId: string;
+}
+/** Data passed to PostToolUse hooks. */
+interface PostToolUseData extends Record<string, unknown> {
+    toolId: string;
+    parameters: Record<string, unknown>;
+    result: string;
+    isError: boolean;
+    conversationId: string;
+}
+/** Data passed to UserPromptSubmit hooks. */
+interface UserPromptSubmitData extends Record<string, unknown> {
+    message: string;
+    conversationId: string;
+}
+/** Data passed to ContextCompaction hooks before built-in history compaction. */
+interface ContextCompactionData extends Record<string, unknown> {
+    conversationId: string;
+    iteration: number;
+    history: ChatMessage[];
+    autoCompact?: AgentFrameworkContext['agentToolLoop'] extends infer Options ? Options extends {
+        autoCompact?: infer AutoCompact;
+    } ? AutoCompact : never : never;
+    contextCompaction?: AgentFrameworkContext['agentToolLoop'] extends infer Options ? Options extends {
+        contextCompaction?: infer ContextCompaction;
+    } ? ContextCompaction : never : never;
+}
+/** Data passed to AgentStart hooks. */
+interface AgentStartData extends Record<string, unknown> {
+    conversationId: string;
+    definitionId?: string;
+}
+/** Data passed to AgentStop hooks. */
+interface AgentStopData extends Record<string, unknown> {
+    conversationId: string;
+    reason: 'completed' | 'cancelled' | 'max-iterations' | 'error';
+}
+
+interface CreateAgentOptions {
+    definitionId: string;
+    initialMessage?: string;
+}
+interface SendMessageOptions {
+    conversationId: string;
+    message: string;
+    definitionId?: string;
+    userMessage?: AgentLoopInput['userMessage'];
+    resumeSession?: ChatMessage[];
+}
+interface MemeLoopRuntime {
+    createAgent(options: CreateAgentOptions): Promise<{
+        conversationId: string;
+    }>;
+    sendMessage(options: SendMessageOptions): Promise<void>;
+    cancelAgent(conversationId: string): Promise<void>;
+    subscribeToUpdates(conversationId: string, listener: (update: unknown) => void): () => void;
+}
+interface CreateAgentLoopRunnerOptions {
+    definitionId: string;
+    conversationId?: string;
+}
+/**
+ * Create a loop runner for an already-resolved profile. Registers builtin
+ * loops/tools/prompts and threads the host script policy through, exactly
+ * like the definition-based path.
+ */
+declare function createAgentProfileRunner(context: AgentFrameworkContext, profile: LoopProfile, runtime?: Partial<AgentLoopRuntime>): Promise<((input: AgentLoopInput) => AgentLoopGenerator) | null>;
+/**
+ * Create a loop runner for a profile with a fresh per-conversation script
+ * runtime (state, checkpoints, cancellation, child propagation). Used by the
+ * workload execution path (plan 24.14) where the profile is synthesized from
+ * a resource rather than resolved from the definition store.
+ */
+declare function createAgentLoopScriptRunner(context: AgentFrameworkContext, profile: LoopProfile, conversationId: string): Promise<((input: AgentLoopInput) => AgentLoopGenerator) | null>;
+declare function createAgentLoopRunner(context: AgentFrameworkContext, options: CreateAgentLoopRunnerOptions): Promise<((input: AgentLoopInput) => AgentLoopGenerator) | null>;
+declare function createMemeLoopRuntime(context: AgentFrameworkContext): MemeLoopRuntime;
+
+/**
+ * Registry for agent profiles used by task delegation.
+ * Pre-seeded with built-in profiles (build, plan, explore, oracle, librarian).
+ */
+declare class AgentProfileRegistry {
+    private readonly profiles;
+    constructor();
+    /** Seed the registry with built-in agent profiles. */
+    private seedDefaults;
+    /**
+     * Register a new agent profile or override an existing one.
+     * Throws if the profile is invalid.
+     */
+    registerAgentProfile(profile: AgentProfile): void;
+    /**
+     * Get an agent profile by ID.
+     * Returns undefined if not found.
+     */
+    getAgentProfile(id: string): AgentProfile | undefined;
+    /**
+     * List all registered agent profiles.
+     */
+    listAgentProfiles(): AgentProfile[];
+    /**
+     * List agent profiles filtered by type.
+     */
+    listAgentProfilesByType(type: AgentProfileType): AgentProfile[];
+    /**
+     * Remove an agent profile by ID.
+     */
+    unregisterAgentProfile(id: string): boolean;
+    /**
+     * Reset the registry to only built-in defaults.
+     */
+    reset(): void;
+}
+declare function getAgentProfileRegistry(): AgentProfileRegistry;
+declare function resetAgentProfileRegistry(): void;
+
+/**
+ * Task category system for routing tasks to appropriate agent configurations.
+ * Each category maps to a model, temperature, and description for delegation decisions.
+ */
+type TaskCategory = 'visual-engineering' | 'ultrabrain' | 'artistry' | 'quick' | 'unspecified-low' | 'unspecified-high' | 'writing';
+interface CategoryConfig {
+    /** Model identifier (e.g., "default", "gpt-4o", "claude-opus") */
+    model: string;
+    /** LLM temperature (0.0 = deterministic, 1.0 = creative) */
+    temperature: number;
+    /** Human-readable description of the category's purpose */
+    description: string;
+}
+/**
+ * Get the configuration for a task category.
+ * @throws {Error} if the category is unknown
+ */
+declare function getCategoryConfig(category: TaskCategory): CategoryConfig;
+/**
+ * Type guard: check if a string is a valid TaskCategory.
+ */
+declare function isTaskCategory(value: string): value is TaskCategory;
+/** All registered category identifiers (read-only). */
+declare const ALL_CATEGORIES: TaskCategory[];
+/**
+ * Resolve a category string (or fallback to "unspecified-low").
+ * Never throws; always returns a valid config.
+ */
+declare function resolveCategory(category: string): CategoryConfig;
+
+/**
+ * Test whether a tool name matches a wildcard pattern.
+ *
+ * Supported patterns:
+ * - `*`       → matches everything
+ * - `file.*`   → matches any tool starting with `file.`
+ * - `shell(*)` → matches tools like `shell(rm)`, `shell(ls)` (literal parens)
+ * - exact name → matches only that exact tool name
+ *
+ * Patterns are converted to anchored regexes internally.
+ */
+declare function matchPattern(toolName: string, pattern: string): boolean;
+/**
+ * Merge multiple permission sets from lowest to highest priority.
+ *
+ * Sets are processed in order; later rules override earlier ones for the same tool pattern.
+ * Within a single set, rules are processed in order (last wins).
+ *
+ * @param sets - Ordered from lowest to highest priority (e.g. default → agent → user → session)
+ * @returns Flattened `MergedPermissions` with all unique patterns per action.
+ */
+declare function mergePermissionSets(sets: PermissionSet[]): MergedPermissions;
+/**
+ * Check what action applies to a given tool name under merged permissions.
+ *
+ * Precedence: exact patterns always beat wildcards.
+ * Within same specificity: deny > ask > allow.
+ */
+declare function checkPermission(toolName: string, merged: MergedPermissions): PermissionAction;
+
+interface PermissionSqlStatement {
+    get(...arguments_: unknown[]): unknown;
+    run(...arguments_: unknown[]): unknown;
+}
+interface PermissionSqlDatabase {
+    prepare(sql: string): PermissionSqlStatement;
+}
+/**
+ * Load user-level permission set from SQLite.
+ *
+ * The `permissions` table stores JSON blobs keyed by `source`.
+ * Returns an empty set if no persisted rules exist.
+ */
+declare function loadUserPermissions(database: PermissionSqlDatabase): PermissionSet;
+/**
+ * Persist user-level permission set to SQLite.
+ *
+ * Uses INSERT OR REPLACE so first-time saves work without explicit table detection.
+ */
+declare function saveUserPermissions(database: PermissionSqlDatabase, set: PermissionSet): void;
+/** SQL statement to create the permissions table during migration. */
+declare const PERMISSIONS_TABLE_DDL = "\n  CREATE TABLE IF NOT EXISTS permissions (\n    source TEXT PRIMARY KEY,\n    rulesJson TEXT NOT NULL,\n    updatedAt INTEGER NOT NULL\n  );\n";
+
+/**
+ * Plugin marketplace architecture types.
+ * Plugins can provide tools and hooks to extend memeloop.
+ */
+
+/**
+ * Plugin manifest schema.
+ * Host adapters may read this from files or construct it programmatically.
+ */
+interface PluginManifest {
+    /** Unique plugin identifier (e.g. "plugin-hello", "@scope/my-plugin") */
+    name: string;
+    /** Semantic version */
+    version: string;
+    /** Human-readable description */
+    description: string;
+    /** Declared exports: what the plugin provides */
+    exports?: PluginExports;
+    /** Plugin author */
+    author?: string;
+    /** Minimum memeloop version requirement (semver range) */
+    minMemeloopVersion?: string;
+}
+/** Declared capabilities a plugin may export. */
+interface PluginExports {
+    /** Tool IDs this plugin implements */
+    tools?: string[];
+    /** Hook types this plugin listens for */
+    hooks?: HookType[];
+}
+/**
+ * Shape of a loaded plugin module's default export.
+ * Plugins must export default an object conforming to this interface.
+ */
+interface PluginModule {
+    /** Plugin identity (must match manifest name) */
+    name: string;
+    /**
+     * Called when the plugin is loaded. Receives the PluginAPI for registering
+     * tools and hooks. Return a cleanup function for teardown.
+     */
+    activate: (api: PluginAPI) => (() => void) | Promise<() => void> | undefined;
+}
+/**
+ * API surface exposed to plugins. Plugins call these methods in their
+ * `activate` function to register their capabilities.
+ */
+interface PluginAPI {
+    /**
+     * Register a tool implementation.
+     * @param toolId - Unique tool ID (e.g. "plugin-hello.sayHi")
+     * @param impl - Tool implementation function
+     * @param schema - Optional parameter schema (Zod type)
+     */
+    registerTool(toolId: string, impl: (...arguments_: unknown[]) => unknown, schema?: unknown, effect?: ToolOperationEffect): void;
+    /**
+     * Register a lifecycle hook handler.
+     * @param type - Hook event type
+     * @param handler - Async handler function
+     * @param name - Optional handler name (enables dedup/unregistration)
+     */
+    registerHook(type: HookType, handler: HookHandler, name?: string): void;
+    /** Log to memeloop's logger (falls back to console). */
+    logger: {
+        debug: (message: string, ...arguments_: unknown[]) => void;
+        info: (message: string, ...arguments_: unknown[]) => void;
+        warn: (message: string, ...arguments_: unknown[]) => void;
+        error: (message: string, ...arguments_: unknown[]) => void;
+    };
+}
+/** Metadata about a loaded plugin instance. */
+interface LoadedPlugin {
+    /** Manifest data */
+    manifest: PluginManifest;
+    /** Optional host-provided source identifier, e.g. package name or file path. */
+    source: string;
+    /** The loaded plugin module */
+    module: PluginModule;
+    /** Cleanup function returned by activate(), if any */
+    cleanup: (() => void) | undefined;
+    /** When the plugin was loaded */
+    loadedAt: Date;
+}
+
+declare function validatePluginManifest(object: unknown): PluginManifest | null;
+interface LoadPluginModuleOptions {
+    manifest: PluginManifest;
+    module: PluginModule;
+    api?: unknown;
+    source?: string;
+}
+declare function loadPluginModule(options: LoadPluginModuleOptions): Promise<LoadedPlugin | null>;
+declare function loadPluginModules(plugins: LoadPluginModuleOptions[]): Promise<LoadedPlugin[]>;
+declare function unloadPlugin(name: string): boolean;
+declare function listPlugins(): LoadedPlugin[];
+declare function getLoadedPlugin(name: string): LoadedPlugin | undefined;
+declare function isPluginLoaded(name: string): boolean;
+declare function unloadAllPlugins(): void;
+
+/**
+ * Plugin registry: bridges plugin exports to memeloop's tool and hook registries.
+ *
+ * Provides a `createPluginAPI()` factory that plugins call during `activate()`
+ * to register their tools and hooks with the host runtime.
+ *
+ * Converted from module-level singletons to an instance class for test isolation
+ * and multi-runtime support.
+ */
+
+/** Plugin API factory options. */
+interface PluginAPIOptions {
+    toolRegistry?: {
+        registerTool(id: string, impl: unknown, schema?: unknown, effect?: ToolOperationEffect): void;
+    };
+    logger?: PluginAPI['logger'];
+}
+/**
+ * Track which tools/plugins belong to each plugin so we can clean up on unload.
+ */
+interface PluginRegistration {
+    pluginName: string;
+    tools: string[];
+    hooks: Array<{
+        type: HookType;
+        name: string;
+    }>;
+}
+declare function createPluginAPI(options?: PluginAPIOptions): PluginAPI;
+declare function registerPluginTools(pluginName: string, tools: Array<readonly [string, (...arguments_: unknown[]) => unknown, unknown?]>): void;
+declare function registerPluginHooks(pluginName: string, hooks: Array<readonly [HookType, HookHandler, string?]>): void;
+declare function getPluginRegistrations(pluginName: string): PluginRegistration | undefined;
+declare function clearPluginRegistrations(): void;
+
+export { resetAgentProfileRegistry as $, ALL_CATEGORIES as A, createAgentLoopScriptRunner as B, type CategoryConfig as C, createAgentProfileRunner as D, createMemeLoopRuntime as E, createPluginAPI as F, getAgentProfileRegistry as G, type HookContext as H, getCategoryConfig as I, getLoadedPlugin as J, getPluginRegistrations as K, type LoadPluginModuleOptions as L, type MemeLoopRuntime as M, isPluginLoaded as N, isTaskCategory as O, PERMISSIONS_TABLE_DDL as P, listPlugins as Q, loadPluginModule as R, type SendMessageOptions as S, type TaskCategory as T, type UserPromptSubmitData as U, loadPluginModules as V, loadUserPermissions as W, matchPattern as X, mergePermissionSets as Y, registerPluginHooks as Z, registerPluginTools as _, AgentProfileRegistry as a, resolveCategory as a0, saveUserPermissions as a1, unloadAllPlugins as a2, unloadPlugin as a3, validatePluginManifest as a4, type AgentStartData as b, type AgentStopData as c, type ContextCompactionData as d, type CreateAgentLoopRunnerOptions as e, type CreateAgentOptions as f, type HookHandler as g, type HookResult as h, type HookType as i, type LoadedPlugin as j, type MergedPermissions as k, type PermissionAction as l, type PermissionRule as m, type PermissionSet as n, type PermissionSqlDatabase as o, type PermissionSqlStatement as p, type PluginAPI as q, type PluginAPIOptions as r, type PluginExports as s, type PluginManifest as t, type PluginModule as u, type PostToolUseData as v, type PreToolUseData as w, checkPermission as x, clearPluginRegistrations as y, createAgentLoopRunner as z };