@mindot/will 0.8.0 → 0.10.0

package/dist/mcp/effectors.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../src/mcp/effectors.ts"],"names":[],"mappings":"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","file":"effectors.js","sourcesContent":["// ─────────────────────────────────────────────────────────────\n// src/mcp/effectors.ts — a Will EMPLOYING MCP tools (Seam 1)\n// ─────────────────────────────────────────────────────────────\n//\n// The other direction from server.ts: connect a Will to an external MCP server\n// and register that server's tools as the Will's own ABILITIES. Each tool\n// becomes a learnable affordance — its description (plus a compact hint of the\n// arguments it takes) is the ability's meaning, surfaced to the executive and\n// the deliberator; the WILL decides when to enact one (nothing here dispatches);\n// the tool's result feeds back through reafference, so the Will gets *skilled*\n// at the tools it uses.\n//\n// Arguments come from conscious intent: the executive supplies them via an\n// action's `args`, which ride the ideomotor leg into the invocation (see\n// executive commands.ts). A tool with required arguments enacted habitually\n// (without args) fails informatively — reafference then teaches the Will that\n// this ability wants deliberate articulation.\n//\n//   const { names, close } = await connectMcpEffectors( will, {\n//     command: 'npx', args: [ '-y', '@modelcontextprotocol/server-filesystem', '/tmp' ],\n//   } )\n//\n// Import from '@mindot/will/mcp' — kept off the main entry so non-MCP\n// consumers never load the MCP SDK.\n// ─────────────────────────────────────────────────────────────\n\nimport { Client } from '@modelcontextprotocol/sdk/client/index.js'\nimport { StdioClientTransport, getDefaultEnvironment } from '@modelcontextprotocol/sdk/client/stdio.js'\nimport { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js'\nimport type { Will, EffectorHandler, EffectorResult } from '#sdk/will'\n\n/** Where the tools live: spawn a local server, reach a remote one, or bring a connected client. */\nexport type McpToolsSource =\n  | { command: string; args?: string[]; env?: Record<string, string> }\n  | { url: string }\n  | { client: Client }\n\nexport interface McpEffectorsOptions {\n  /** Intrinsic effort prior 0..1 seeded on every bridged ability (default 0.2). */\n  cost?: number\n  /** Prefix for the ability names (e.g. 'fs_') — avoids collisions across servers. */\n  prefix?: string\n}\n\n/** Minimal structural view of an MCP tool (the SDK's zod-inferred type, loosened). */\nexport interface McpToolInfo {\n  name:         string\n  description?: string\n  inputSchema?: {\n    type?:       string\n    properties?: Record<string, { type?: string; description?: string }>\n    required?:   string[]\n  }\n}\n\n/** Keep tool outcomes bounded — the description feeds reafference + episodic memory. */\nconst RESULT_DESCRIPTION_CAP = 700\n/** Keep ability meanings bounded — they render into the executive prompt. */\nconst MEANING_CAP = 300\n\n/**\n * The ability's *meaning*: the tool's description plus a compact hint of the\n * arguments it takes — so the executive knows what to supply in an action's\n * `args` when it enacts this ability.\n */\nexport function describeMcpTool( tool: McpToolInfo ): string {\n  const props    = tool.inputSchema?.properties ?? {}\n  const required = new Set( tool.inputSchema?.required ?? [] )\n  const argHints = Object.entries( props ).map( ( [ key, p ] ) =>\n    `${ key }${ required.has( key ) ? '' : '?' }${ p.description ? `: ${ p.description }` : '' }`)\n\n  const base = ( tool.description ?? `The ${ tool.name } tool.`).trim().replace( /\\s+/g, ' ')\n  const hint = argHints.length > 0 ? ` (args — ${ argHints.join('; ') })` : ''\n  const full = `${ base }${ hint }`\n  return full.length > MEANING_CAP ? `${ full.slice( 0, MEANING_CAP - 1 ) }…` : full\n}\n\n/**\n * The effector handler for one bridged tool: checks required args (an ability\n * enacted without its needed articulation fails informatively — reafference\n * learns from it), calls the tool, and maps the result onto EffectorResult.\n */\nexport function buildMcpHandler( client: Client, tool: McpToolInfo ): EffectorHandler {\n  return async ( args ): Promise<EffectorResult> => {\n    const props = tool.inputSchema?.properties\n    // Only pass keys the tool declares — invocation params can carry situation\n    // extras (targetEntityName, learned priors) the tool never asked for.\n    const filtered: Record<string, unknown> = {}\n    for( const [ k, v ] of Object.entries( args ?? {} ) )\n      if( !props || k in props ) filtered[ k ] = v\n\n    const missing = ( tool.inputSchema?.required ?? [] ).filter(\n      k => filtered[ k ] === undefined || filtered[ k ] === '')\n    if( missing.length > 0 )\n      return {\n        success: false,\n        description: `${ tool.name } needs ${ missing.join(', ') } — enact it deliberately, supplying them in the action's args.`,\n      }\n\n    try {\n      const res  = await client.callTool( { name: tool.name, arguments: filtered } ) as\n        { content?: Array<{ type: string; text?: string }>; isError?: boolean }\n      const text = ( res.content ?? [] )\n        .filter( c => c.type === 'text' && typeof c.text === 'string')\n        .map( c => c.text as string )\n        .join('\\n')\n        .trim() || ( res.isError ? 'The tool reported an error.' : 'Done (no output).')\n      const bounded = text.length > RESULT_DESCRIPTION_CAP ? `${ text.slice( 0, RESULT_DESCRIPTION_CAP - 1 ) }…` : text\n      return { success: !res.isError, description: bounded }\n    }\n    catch( err ){\n      return { success: false, description: `${ tool.name } failed: ${ err instanceof Error ? err.message : String( err ) }` }\n    }\n  }\n}\n\nasync function connect( source: McpToolsSource ): Promise<{ client: Client; owned: boolean }> {\n  if('client' in source ) return { client: source.client, owned: false }\n\n  const client = new Client( { name: 'mindot-will', version: '0' } )\n  if('url' in source )\n    await client.connect( new StreamableHTTPClientTransport( new URL( source.url ) ) )\n  else\n    await client.connect( new StdioClientTransport( {\n      command: source.command,\n      ...( source.args ? { args: source.args } : {} ),\n      // Merge over the SDK's safe default env so PATH etc. survive a custom env.\n      env: { ...getDefaultEnvironment(), ...( source.env ?? {} ) },\n    } ) )\n  return { client, owned: true }\n}\n\n/**\n * Register an MCP server's tools as the Will's abilities. Returns the ability\n * names registered and a `close()` for the connection (call it when the Will\n * stops; a client passed in via `source.client` is left open).\n */\nexport async function connectMcpEffectors(\n  will:   Will,\n  source: McpToolsSource,\n  opts:   McpEffectorsOptions = {},\n): Promise<{ names: string[]; close: () => Promise<void> }> {\n  const { client, owned } = await connect( source )\n  const { tools } = await client.listTools() as unknown as { tools: McpToolInfo[] }\n\n  const names: string[] = []\n  for( const tool of tools ){\n    const name = `${ opts.prefix ?? '' }${ tool.name }`\n    will.effector( name, {\n      description: describeMcpTool( tool ),\n      cost:        opts.cost ?? 0.2,\n      tags:        [ 'mcp' ],\n      handler:     buildMcpHandler( client, tool ),\n    } )\n    names.push( name )\n  }\n\n  return { names, close: async () => { if( owned ) await client.close() } }\n}\n"]}

package/src/channels/discord.ts

@@ -1,214 +0,0 @@
-// ─────────────────────────────────────────────────────────────
-// src/channels/discord.ts — a Will present in a Discord server
-// ─────────────────────────────────────────────────────────────
-//
-// The bridge relays both directions of the paradigm and nothing else:
-//
-//   inbound   guild/DM message → will.perceive({ from, speaker, text, thread })
-//             — every author is `discord:<userId>` (stable across guilds), the
-//             display name is *learned* by the mind, and each Discord channel
-//             is its own conversation thread.
-//   outbound  will.on('message') → the addressee's last shared channel, else
-//             their DM, else the home channel. Proactive utterances (the mind
-//             speaking first) route the same way — that is the point.
-//
-// The Will decides when to speak. There is no command prefix and no forced
-// reply: unaddressed chatter is perceived (salience-scored by audition) and
-// silence is a valid outcome. `mentionOnly` narrows perception for busy
-// servers; it does not turn the bridge into an ask() surface.
-//
-// discord.js is imported lazily inside `createDiscordClient` — tests (and any
-// host that brings its own client) inject `client`, and the structural
-// `DiscordLikeClient` type keeps the dependency out of the type graph.
-// ─────────────────────────────────────────────────────────────
-
-import type { Will, WillMessage } from '#sdk/will'
-import { ChannelRoster } from '#channels/roster'
-import { chunkText, type ChannelBridge } from '#channels/types'
-
-const DISCORD_MESSAGE_LIMIT = 2000
-
-// ── The slice of discord.js the bridge actually uses (structural) ───────────
-
-export interface DiscordLikeChannel {
-  send( content: string ): Promise<unknown>
-  sendTyping?(): Promise<unknown>
-}
-
-export interface DiscordLikeMessage {
-  content: string
-  cleanContent?: string
-  channelId: string
-  guildId?: string | null
-  author: { id: string; bot?: boolean; username?: string; displayName?: string }
-  member?: { displayName?: string } | null
-  mentions?: { has( userId: string ): boolean }
-  channel: DiscordLikeChannel
-}
-
-export interface DiscordLikeClient {
-  user: { id: string; setPresence?( p: unknown ): void } | null
-  /** discord.js ≥14.22; polled so we needn't subscribe to the deprecated `ready`. */
-  isReady?(): boolean
-  on( event: 'messageCreate', fn: ( m: DiscordLikeMessage ) => void ): unknown
-  once( event: string, fn: () => void ): unknown
-  login( token: string ): Promise<unknown>
-  destroy(): Promise<unknown> | void
-  channels: { fetch( id: string ): Promise<unknown> }
-  users: { fetch( id: string ): Promise<{ send( content: string ): Promise<unknown> }> }
-}
-
-// ── Options ──────────────────────────────────────────────────────────────────
-
-export interface DiscordBridgeOptions {
-  /** Bot token (Discord developer portal). Unused when `client` is injected pre-logged-in. */
-  token?: string
-  /** Channel ids the Will inhabits. Unset = every channel it can see. */
-  channels?: string[]
-  /** Perceive guild messages only when the Will is @mentioned (DMs always perceived). */
-  mentionOnly?: boolean
-  /** Fallback channel for utterances with no reachable addressee. */
-  homeChannelId?: string
-  /** Roster path (default: ./.will/<willId>.discord.json). */
-  rosterPath?: string
-  /** Test / power-user seam: bring your own client; discord.js is never imported. */
-  client?: DiscordLikeClient
-  log?: ( msg: string ) => void
-}
-
-// ── The bridge ───────────────────────────────────────────────────────────────
-
-/**
- * Connect a Will to Discord. Resolves once the bridge is live (logged in and
- * relaying). Close it via the returned `ChannelBridge.close()` — the Will
- * itself is not stopped; it simply loses this surface.
- */
-export async function connectDiscord( will: Will, opts: DiscordBridgeOptions ): Promise<ChannelBridge> {
-  const log     = opts.log ?? ( ( m: string ) => console.error(`[will:discord] ${ m }`) )
-  const roster  = new ChannelRoster( opts.rosterPath ?? `.will/${ will.id }.discord.json`)
-  const allowed = opts.channels?.length ? new Set( opts.channels ) : null
-
-  const client = opts.client ?? await createDiscordClient()
-
-  /** The most recently active allowed channel — last-resort proactive target. */
-  let lastActiveChannelId: string | null = opts.homeChannelId ?? null
-
-  // ── inbound: platform message → stimulus ──────────────────────────────────
-  client.on('messageCreate', message => { void onMessage( message ) } )
-
-  async function onMessage( message: DiscordLikeMessage ): Promise<void> {
-    const self = client.user
-    if( !self || message.author.id === self.id || message.author.bot ) return
-
-    const isDM = !message.guildId
-    if( !isDM && allowed && !allowed.has( message.channelId ) ) return
-
-    const addressed = isDM || ( message.mentions?.has( self.id ) ?? false )
-    if( opts.mentionOnly && !addressed ) return
-
-    const entityId = `discord:${ message.author.id }`
-    const speaker  = message.member?.displayName ?? message.author.displayName ?? message.author.username
-
-    roster.record( {
-      entityId,
-      userId: message.author.id,
-      ...( speaker ? { displayName: speaker } : {} ),
-      ...( isDM ? { dmChannelId: message.channelId } : { lastChannelId: message.channelId } ),
-    } )
-    if( !isDM ) lastActiveChannelId = message.channelId
-
-    // Being addressed is the one moment a presence cue is honest — the mind
-    // may still choose silence, and typing expires on its own.
-    if( addressed ) await message.channel.sendTyping?.().catch( () => {} )
-
-    const text = message.cleanContent || message.content
-    if( !text.trim() ) return
-
-    await will.perceive( {
-      text,
-      from:   entityId,
-      thread: `discord:${ message.channelId }`,
-      ...( speaker ? { speaker } : {} ),
-    } )
-  }
-
-  // ── outbound: projected utterance → the addressee ─────────────────────────
-  // The facade has no off(); the bridge gates its handler on `closed` instead.
-  let closed = false
-  will.on('message', ( m: WillMessage ) => { if( !closed ) void deliver( m ) } )
-
-  async function deliver( m: WillMessage ): Promise<void> {
-    const peer = m.to ? roster.resolve( m.to ) : undefined
-    const chunks = chunkText( m.content, DISCORD_MESSAGE_LIMIT )
-
-    // Preference order: where we last shared a room → their DM → home channel.
-    const channelIds = [ peer?.lastChannelId, peer?.dmChannelId, opts.homeChannelId ?? undefined, lastActiveChannelId ?? undefined ]
-    for( const id of channelIds ){
-      if( !id ) continue
-      try {
-        const channel = await client.channels.fetch( id ) as DiscordLikeChannel | null
-        if( !channel?.send ) continue
-        for( const chunk of chunks ) await channel.send( chunk )
-        return
-      }
-      catch { /* try the next route */ }
-    }
-    if( peer ){
-      try {
-        const user = await client.users.fetch( peer.userId )
-        for( const chunk of chunks ) await user.send( chunk )
-        return
-      }
-      catch { /* fall through */ }
-    }
-    log(`no route for utterance to '${ m.to }' — dropped (${ m.content.length } chars)`)
-  }
-
-  // ── lifecycle ──────────────────────────────────────────────────────────────
-  const bridge: ChannelBridge = {
-    kind: 'discord',
-    async start(): Promise<void> {
-      if( !client.user ){
-        // discord.js ≥14.22 renamed `ready` → `clientReady`. Subscribing to the
-        // old name is what triggers its DeprecationWarning, so we take the new
-        // name and poll `isReady()` for older builds rather than listening.
-        const ready = new Promise<void>( resolve => {
-          let poll: ReturnType<typeof setInterval> | null = null
-          const done = (): void => { if( poll ) clearInterval( poll ); resolve() }
-          client.once('clientReady', done )
-          poll = setInterval( () => { if( client.isReady?.() ) done() }, 100 )
-          poll.unref?.()
-        } )
-        await client.login( opts.token ?? '')
-        await ready
-      }
-      log(`${ will.name } is present on Discord as user ${ client.user?.id }`)
-    },
-    async close(): Promise<void> {
-      if( closed ) return
-      closed = true
-      roster.flush()
-      await Promise.resolve( client.destroy() ).catch( () => {} )
-    },
-  }
-  return bridge
-}
-
-/** Build a real discord.js client (lazy import keeps it out of non-Discord hosts). */
-async function createDiscordClient(): Promise<DiscordLikeClient> {
-  let mod: typeof import('discord.js')
-  try { mod = await import('discord.js') }
-  catch {
-    throw new Error('discord.js is not installed (it is an optionalDependency) — run `bun add discord.js` / `npm i discord.js` and retry.')
-  }
-  const { Client, GatewayIntentBits, Partials } = mod
-  return new Client( {
-    intents: [
-      GatewayIntentBits.Guilds,
-      GatewayIntentBits.GuildMessages,
-      GatewayIntentBits.MessageContent,
-      GatewayIntentBits.DirectMessages,
-    ],
-    partials: [ Partials.Channel ],   // DMs arrive on uncached channels
-  } ) as unknown as DiscordLikeClient
-}

package/src/channels/types.ts

@@ -1,46 +0,0 @@
-// ─────────────────────────────────────────────────────────────
-// src/channels/types.ts — the channel-bridge contract
-// ─────────────────────────────────────────────────────────────
-//
-// A channel bridge puts a Will *in a place where people already are* (Discord,
-// Telegram, Slack, …). It is a host surface, not a cognition surface: it turns
-// platform messages into `perceive` stimuli and delivers the Will's projected
-// utterances back — nothing more. The paradigm survives the crossing:
-//
-//   • every platform user is an entity the Will comes to know (`from`),
-//     with a *learned* name (`speaker`) — never a placeholder;
-//   • every platform channel/DM is a conversation thread (`thread`);
-//   • the Will decides when to speak. Silence is a valid outcome, so a
-//     bridge never fabricates a reply and never times a message out into
-//     an error.
-//
-// Bridges live at the same altitude as the MCP/HTTP hosts (src/mcp, src/serve):
-// they wrap the SDK facade, not the stem.
-// ─────────────────────────────────────────────────────────────
-
-/** A running connection between one Will and one platform. */
-export interface ChannelBridge {
-  /** Platform kind, e.g. 'discord'. */
-  readonly kind: string
-  /** Connect and start relaying. Resolves once the bridge is live. */
-  start(): Promise<void>
-  /** Disconnect and release resources. Idempotent. */
-  close(): Promise<void>
-}
-
-/** Split a message into platform-sized chunks on natural boundaries. */
-export function chunkText( text: string, max: number ): string[] {
-  if( text.length <= max ) return [ text ]
-  const chunks: string[] = []
-  let rest = text
-  while( rest.length > max ){
-    // Prefer a paragraph break, then a line break, then a space — else hard-cut.
-    const window = rest.slice( 0, max )
-    const cut = Math.max( window.lastIndexOf('\n\n'), window.lastIndexOf('\n'), window.lastIndexOf(' ') )
-    const at = cut > max * 0.5 ? cut : max
-    chunks.push( rest.slice( 0, at ).trimEnd() )
-    rest = rest.slice( at ).trimStart()
-  }
-  if( rest ) chunks.push( rest )
-  return chunks
-}

package/src/cognition/faculties/executive.engine/messages.ts

@@ -1,102 +0,0 @@
-// ─────────────────────────────────────────────────────────────
-// src/cognition/faculties/executive.engine/messages.ts
-// ─────────────────────────────────────────────────────────────
-
-import { logger } from '#core/logger'
-import type { Tick, ReadonlySimulationState } from '#core/types'
-import type { PendingMessage } from '#faculties/executive.engine/types'
-
-/**
- * Message queue state — tracks incoming communication entities,
- * pending messages during in-flight LLM calls, and reply deduplication.
- */
-export class MessageQueue {
-  /** Messages buffered while an LLM call is in-flight. */
-  pendingMessages: PendingMessage[] = []
-
-  /** Tick when the current (or most recent) LLM call started. */
-  pendingCallStartTick: number = -1
-
-  /** Entity IDs of communication entities that have been replied to this session. */
-  private _repliedEntityIds = new Set<string>()
-
-  /**
-   * Scan the simulation state for unprocessed communication entities
-   * and queue them into pendingMessages. Call every tick.
-   */
-  scanState( state: ReadonlySimulationState, tick: Tick ): void {
-    const seenIds = new Set( this.pendingMessages.map( m => m.id ) )
-
-    for( const [ id, entity ] of state.entities ){
-      if( entity.type !== 'communication') continue
-      if( entity.metadata?.processedByExecutive ) continue
-      if( seenIds.has( id ) ) continue
-
-      const msgTick = ( entity.metadata?.tick as number ) ?? 0
-      this.pendingMessages.push({
-        id,
-        content: (entity.metadata?.content as string) ?? '',
-        sender: (entity.metadata?.agentName as string) ?? 'unknown',
-        senderId: (entity.metadata?.keid as string) ?? 'unknown',
-        tick: msgTick
-      })
-
-      logger.info(`[executive] queued message from ${(entity.metadata?.agentName as string) ?? 'unknown'} (tick=${msgTick})`)
-    }
-  }
-
-  /**
-   * Clear messages that were included in the most recent LLM call.
-   * Any that arrived after the call started remain for the next cycle.
-   */
-  clearProcessedMessages(): void {
-    this.pendingMessages = this.pendingMessages.filter( m => m.tick > this.pendingCallStartTick )
-  }
-
-  /**
-   * Check if we've already replied to a specific communication entity this session.
-   */
-  hasRepliedTo( entityId: string ): boolean {
-    return this._repliedEntityIds.has( entityId )
-  }
-
-  /**
-   * Mark a communication entity as replied to.
-   */
-  markReplied( entityId: string ): void {
-    this._repliedEntityIds.add( entityId )
-  }
-
-  /**
-   * Build the set of communication entity IDs visible in state within the
-   * 30-tick window, plus any pending messages. Used to mark them as processed.
-   */
-  getVisibleMessageIds( state: ReadonlySimulationState, tick: Tick ): Set<string> {
-    const ids = new Set<string>( this.pendingMessages.map( m => m.id ) )
-    for( const [ id, entity ] of state.entities ){
-      if( entity.type !== 'communication') continue
-
-      const msgTick = (entity.metadata?.tick as number) ?? 0
-      if( tick - msgTick > 30 ) continue
-
-      ids.add( id )
-    }
-
-    return ids
-  }
-
-  /**
-   * Get stale communication entity IDs (>50 ticks old) for cleanup.
-   */
-  getStaleMessageIds( state: ReadonlySimulationState, tick: Tick ): string[] {
-    const stale: string[] = []
-    for( const [ id, entity ] of state.entities ){
-      if( entity.type !== 'communication') continue
-
-      const msgTick = (entity.metadata?.tick as number) ?? 0
-      tick - msgTick > 50 && stale.push( id )
-    }
-
-    return stale
-  }
-}