mu-core 0.15.0 → 0.16.3

package/src/hooks.ts

@@ -1,112 +0,0 @@
-import type { AgentEndReason, BeforeToolExecResult, LifecycleHooks, TurnResult, UserInputTransform } from './plugin';
-import type { ChatMessage, ProviderConfig, ToolCall } from './types/llm';
-
-export async function runBeforeLlmHooks(
-  hooks: LifecycleHooks[],
-  messages: ChatMessage[],
-  config: ProviderConfig,
-): Promise<ChatMessage[]> {
-  let current = messages;
-  for (const hook of hooks) {
-    if (hook.beforeLlmCall) {
-      current = await hook.beforeLlmCall(current, config);
-    }
-  }
-  return current;
-}
-
-export async function runAfterLlmHooks(hooks: LifecycleHooks[], result: TurnResult): Promise<TurnResult> {
-  let current = result;
-  for (const hook of hooks) {
-    if (hook.afterLlmCall) {
-      current = await hook.afterLlmCall(current);
-    }
-  }
-  return current;
-}
-
-/**
- * Run every `beforeToolExec` hook in order. Each hook may either return a
- * (possibly mutated) `ToolCall` to keep the chain going, or a `ToolBlock` to
- * short-circuit execution. Once a hook blocks the call, no further hooks run
- * — there's nothing useful to forward.
- */
-export async function runBeforeToolExecHook(
-  hooks: LifecycleHooks[],
-  toolCall: ToolCall,
-): Promise<BeforeToolExecResult> {
-  let current: BeforeToolExecResult = toolCall;
-  for (const hook of hooks) {
-    if (!hook.beforeToolExec) continue;
-    if ('blocked' in current) return current;
-    current = await hook.beforeToolExec(current);
-  }
-  return current;
-}
-
-export async function runAfterToolExecHook(
-  hooks: LifecycleHooks[],
-  toolCall: ToolCall,
-  result: string,
-): Promise<string> {
-  let current = result;
-  for (const hook of hooks) {
-    if (hook.afterToolExec) {
-      current = await hook.afterToolExec(toolCall, current);
-    }
-  }
-  return current;
-}
-
-/**
- * Pipe a freshly built `ChatMessage` through every `decorateMessage` hook in
- * order. Each hook may return a (possibly mutated) message; later hooks see
- * the result of the previous one. Used to stamp display hints (agent badge,
- * color) without coupling the host to any specific plugin.
- */
-export async function runDecorateMessageHooks(hooks: LifecycleHooks[], msg: ChatMessage): Promise<ChatMessage> {
-  let current = msg;
-  for (const hook of hooks) {
-    if (hook.decorateMessage) {
-      current = await hook.decorateMessage(current);
-    }
-  }
-  return current;
-}
-
-export async function runAfterAgentRunHooks(hooks: LifecycleHooks[], reason: AgentEndReason): Promise<void> {
-  for (const hook of hooks) {
-    if (hook.afterAgentRun) {
-      await hook.afterAgentRun(reason);
-    }
-  }
-}
-
-/**
- * Compose every `transformUserInput` hook. Earlier hooks see the raw text;
- * each subsequent hook sees the (possibly rewritten) text emitted by the
- * previous one. The first `intercept` or `continue` short-circuits the chain
- * — once a plugin has either suppressed the input or appended the user
- * message itself, downstream hooks can't safely keep transforming absent
- * text, and the host needs to see the terminating signal verbatim so it
- * skips its own user-message push (see `useOnSend`).
- */
-export async function runTransformUserInputHooks(hooks: LifecycleHooks[], text: string): Promise<UserInputTransform> {
-  let current: UserInputTransform = { kind: 'pass' };
-  let working = text;
-  for (const hook of hooks) {
-    if (!hook.transformUserInput) continue;
-    const next = await hook.transformUserInput(working);
-    if (next.kind === 'intercept') {
-      return next;
-    }
-    if (next.kind === 'continue') {
-      return next;
-    }
-    if (next.kind === 'transform') {
-      working = next.text;
-      current = next;
-    }
-  }
-  return current;
-}

package/src/host/index.ts

@@ -1,135 +0,0 @@
-/**
- * `startMu` — generic host bootstrap. Loads a config, builds the plugin
- * registry with the new side-channel registries (providers/channels/sessions/
- * activity/agents), activates plugins (config first then code-passed), starts
- * channels, and returns a handle for shutdown.
- *
- * Designed for non-coding hosts (Arya etc.). mu-coding currently keeps its
- * own bootstrap (Ink TUI lifecycle) and may migrate to this entry point in a
- * later iteration.
- */
-
-import type { ActivityBus } from '../activity';
-import { createActivityBus } from '../activity';
-import type { ChannelRegistry } from '../channel';
-import { createChannelRegistry } from '../channel';
-import type { Plugin } from '../plugin';
-import type { ProviderRegistry } from '../provider/registry';
-import { createProviderRegistry } from '../provider/registry';
-import { PluginRegistry } from '../registry';
-import type { SessionManager } from '../session';
-import { createSessionManager } from '../session';
-import type { ProviderConfig } from '../types/llm';
-
-export interface MuConfigShape {
-  cwd?: string;
-  baseUrl?: string;
-  model?: string;
-  maxTokens?: number;
-  temperature?: number;
-  streamTimeoutMs?: number;
-  systemPrompt?: string;
-  plugins?: Array<string | { name: string; config?: Record<string, unknown> }>;
-}
-
-export interface StartMuOptions {
-  configPath?: string;
-  /** In-memory config — takes precedence over `configPath` when provided. */
-  config?: MuConfigShape;
-  /** Plugins passed in code (activated after config-listed plugins). */
-  plugins?: Plugin[];
-  /** Cwd default (overrides config.cwd if set). */
-  cwd?: string;
-  /**
-   * Resolves a `config.plugins` entry to a Plugin instance. Hosts (mu-coding,
-   * Arya) plug their own loader here — typically supports `npm:<name>`
-   * specifiers, absolute paths, etc. When omitted, config.plugins is ignored.
-   */
-  resolvePlugin?: (entry: string | { name: string; config?: Record<string, unknown> }) => Promise<Plugin | null>;
-}
-
-export interface MuHandle {
-  registry: PluginRegistry;
-  sessions: SessionManager;
-  channels: ChannelRegistry;
-  activity: ActivityBus;
-  providers: ProviderRegistry;
-  shutdown: () => Promise<void>;
-}
-
-async function loadConfig(opts: StartMuOptions): Promise<MuConfigShape> {
-  if (opts.config) return opts.config;
-  if (!opts.configPath) return {};
-  const { readFileSync, existsSync } = await import('node:fs');
-  if (!existsSync(opts.configPath)) return {};
-  const text = readFileSync(opts.configPath, 'utf8');
-  return JSON.parse(text) as MuConfigShape;
-}
-
-export async function startMu(options: StartMuOptions = {}): Promise<MuHandle> {
-  const cfg = await loadConfig(options);
-  const cwd = options.cwd ?? cfg.cwd ?? process.cwd();
-
-  const providers = createProviderRegistry();
-  const channels = createChannelRegistry();
-  const activity = createActivityBus();
-
-  const providerConfig: ProviderConfig = {
-    baseUrl: cfg.baseUrl ?? 'http://localhost:11434/v1',
-    model: cfg.model,
-    maxTokens: cfg.maxTokens ?? 4096,
-    temperature: cfg.temperature ?? 0.7,
-    streamTimeoutMs: cfg.streamTimeoutMs ?? 60_000,
-    systemPrompt: cfg.systemPrompt,
-  };
-
-  // Build a placeholder for sessions injected after construction (circular:
-  // SessionManager needs the registry, plugins want to see SessionManager).
-  let sessions: SessionManager | null = null;
-  const sessionsProxy: SessionManager = new Proxy({} as SessionManager, {
-    get(_t, prop) {
-      if (!sessions) throw new Error('SessionManager not yet initialised');
-      return (sessions as unknown as Record<string | symbol, unknown>)[prop as string];
-    },
-  });
-
-  const registry = new PluginRegistry({
-    cwd,
-    config: {},
-    providers,
-    channels,
-    activity,
-    sessions: sessionsProxy,
-  });
-
-  sessions = createSessionManager({ registry, config: providerConfig, model: cfg.model ?? 'unknown' });
-
-  // Activate config-listed plugins via the host's resolver. mu-coding wires
-  // its npm:/path loader; minimal hosts may omit and pass plugins in code.
-  if (options.resolvePlugin && cfg.plugins) {
-    for (const entry of cfg.plugins) {
-      const plugin = await options.resolvePlugin(entry);
-      if (plugin) await registry.register(plugin);
-    }
-  }
-  // Activate code-passed plugins after config-listed ones (so code overrides
-  // config-driven hooks compose-wise).
-  for (const plugin of options.plugins ?? []) {
-    await registry.register(plugin);
-  }
-
-  await channels.startAll();
-
-  const sm = sessions;
-  return {
-    registry,
-    sessions: sm,
-    channels,
-    activity,
-    providers,
-    async shutdown() {
-      await channels.stopAll();
-      for (const s of sm.list()) s.abort();
-    },
-  };
-}

package/src/host/startMu.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from 'bun:test';
-import type { Plugin } from '../plugin';
-import { startMu } from './index';
-
-function makePlugin(name: string, marks: string[]): Plugin {
-  return {
-    name,
-    activate() {
-      marks.push(`activate:${name}`);
-    },
-  };
-}
-
-describe('startMu', () => {
-  it('activates code-passed plugins in order', async () => {
-    const marks: string[] = [];
-    const handle = await startMu({
-      plugins: [makePlugin('a', marks), makePlugin('b', marks)],
-    });
-    expect(marks).toEqual(['activate:a', 'activate:b']);
-    await handle.shutdown();
-  });
-
-  it('exposes provider/channel/activity/sessions registries', async () => {
-    const handle = await startMu({});
-    expect(handle.providers.list()).toEqual([]);
-    expect(handle.channels.list()).toEqual([]);
-    expect(handle.sessions.list()).toEqual([]);
-    expect(typeof handle.activity.emit).toBe('function');
-    await handle.shutdown();
-  });
-
-  it('config-listed plugins are activated before code-passed', async () => {
-    const marks: string[] = [];
-    const cfgPlugin = makePlugin('cfg', marks);
-    const codePlugin = makePlugin('code', marks);
-    const handle = await startMu({
-      config: { plugins: ['cfg'] },
-      plugins: [codePlugin],
-      resolvePlugin: async (entry) => (typeof entry === 'string' && entry === 'cfg' ? cfgPlugin : null),
-    });
-    expect(marks).toEqual(['activate:cfg', 'activate:code']);
-    await handle.shutdown();
-  });
-
-  it('starts all registered channels', async () => {
-    const startMarks: string[] = [];
-    const handle = await startMu({
-      plugins: [
-        {
-          name: 'chan-plugin',
-          activate(ctx) {
-            ctx.channels?.register({
-              id: 'test',
-              async start() {
-                startMarks.push('started');
-              },
-            });
-          },
-        },
-      ],
-    });
-    expect(startMarks).toEqual(['started']);
-    await handle.shutdown();
-  });
-});

package/src/index.ts

@@ -1,74 +0,0 @@
-export type { ActivityBus, ActivityEvent, ActivityKind, SubAgentEvent, SubAgentEventKind } from './activity';
-export { createActivityBus } from './activity';
-export { runAgent } from './agent';
-export type { Channel, ChannelRegistry, ChannelResponder, InboundKind, InboundMessage, ResponseMode } from './channel';
-export { createChannelRegistry } from './channel';
-export { runDecorateMessageHooks, runTransformUserInputHooks } from './hooks';
-export type { MuConfigShape, MuHandle, StartMuOptions } from './host/index';
-export { startMu } from './host/index';
-export type {
-  AgentEndReason,
-  AgentEvent,
-  AgentLoopStrategy,
-  AgentSourceRegistry,
-  BeforeToolExecResult,
-  CommandContext,
-  InputInfoSegment,
-  LifecycleHooks,
-  MentionCompletion,
-  MentionProvider,
-  MessageBus,
-  MessageRenderer,
-  Plugin,
-  PluginContext,
-  PluginExtras,
-  PluginRegistryView,
-  PluginTool,
-  PluginToolPermission,
-  ShortcutHandler,
-  SlashCommand,
-  StatusSegment,
-  ToolBlock,
-  ToolDisplayHint,
-  ToolExecutor,
-  ToolExecutorResult,
-  ToolResult,
-  TurnResult,
-  UserInputTransform,
-} from './plugin';
-export type {
-  ChatRequestInput,
-  ModelsRequestInput,
-  ParsedChatEvent,
-  Provider,
-  ProviderAdapter,
-  RequestSpec,
-} from './provider/adapter';
-export { createProvider } from './provider/adapter';
-export type { ProviderRegistry } from './provider/registry';
-export { createProviderRegistry } from './provider/registry';
-export { fetchWithIdleTimeout, readNDJSON, readSSE } from './provider/transport';
-export { PluginRegistry, type PluginRegistryOptions } from './registry';
-export type {
-  CreateSessionManagerOptions,
-  RunTurnOptions,
-  Session,
-  SessionEvent,
-  SessionInit,
-  SessionManager,
-} from './session';
-export { createSessionManager } from './session';
-export type {
-  ApiModel,
-  ChatMessage,
-  ImageAttachment,
-  MessageDisplay,
-  ProviderConfig,
-  StreamChunk,
-  StreamOptions,
-  ToolCall,
-  ToolDefinition,
-  ToolResultInfo,
-  Usage,
-} from './types/llm';
-export { ConsoleUIService, type UINotifyLevel, type UIService } from './ui';