@swarmclawai/swarmclaw 0.2.0

package/src/lib/server/session-tools/context-mgmt.ts

@@ -0,0 +1,103 @@
+import { z } from 'zod'
+import { tool, type StructuredToolInterface } from '@langchain/core/tools'
+import { loadSessions, saveSessions } from '../storage'
+import type { ToolBuildContext } from './context'
+
+export function buildContextTools(bctx: ToolBuildContext): StructuredToolInterface[] {
+  const tools: StructuredToolInterface[] = []
+  const { ctx, activeTools, resolveCurrentSession } = bctx
+
+  if (activeTools.length > 0) {
+    tools.push(
+      tool(
+        async () => {
+          try {
+            const { getContextStatus } = await import('../context-manager')
+            const session = resolveCurrentSession()
+            if (!session) return 'Error: no current session context.'
+            const messages = session.messages || []
+            const systemPromptTokens = 2000
+            const status = getContextStatus(messages, systemPromptTokens, session.provider, session.model)
+            return JSON.stringify(status)
+          } catch (err: any) {
+            return `Error: ${err.message || String(err)}`
+          }
+        },
+        {
+          name: 'context_status',
+          description: 'Check current context window usage for this session. Returns estimated tokens used, provider context limit, percentage used, and compaction strategy recommendation.',
+          schema: z.object({}),
+        },
+      ),
+    )
+
+    tools.push(
+      tool(
+        async ({ keepLastN }) => {
+          try {
+            const { summarizeAndCompact } = await import('../context-manager')
+            const session = resolveCurrentSession()
+            if (!session) return 'Error: no current session context.'
+            if (!ctx?.sessionId) return 'Error: no session id in context.'
+            const messages = session.messages || []
+            const keep = Math.max(2, Math.min(keepLastN || 10, messages.length))
+
+            if (messages.length <= keep) {
+              return JSON.stringify({ status: 'no_action', reason: 'Not enough messages to compact', messageCount: messages.length })
+            }
+
+            const generateSummary = async (text: string): Promise<string> => {
+              const lines = text.split('\n\n').filter(Boolean)
+              const keyLines: string[] = []
+              for (const line of lines) {
+                if (line.length > 20) {
+                  keyLines.push(line.slice(0, 200))
+                }
+              }
+              let summary = ''
+              for (const line of keyLines) {
+                if (summary.length + line.length > 2000) break
+                summary += line + '\n'
+              }
+              return summary.trim() || 'Previous conversation context was pruned.'
+            }
+
+            const result = await summarizeAndCompact({
+              messages,
+              keepLastN: keep,
+              agentId: ctx?.agentId || session.agentId || null,
+              sessionId: ctx.sessionId,
+              generateSummary,
+            })
+
+            const sessions = loadSessions()
+            const target = sessions[ctx.sessionId]
+            if (target) {
+              target.messages = result.messages
+              saveSessions(sessions)
+            }
+
+            return JSON.stringify({
+              status: 'compacted',
+              prunedCount: result.prunedCount,
+              memoriesStored: result.memoriesStored,
+              summaryAdded: result.summaryAdded,
+              remainingMessages: result.messages.length,
+            })
+          } catch (err: any) {
+            return `Error: ${err.message || String(err)}`
+          }
+        },
+        {
+          name: 'context_summarize',
+          description: 'Summarize and compact the conversation history to free context window space. Old messages are consolidated to memory (preserving decisions, key facts, results) and replaced with a summary. Use context_status first to check if compaction is needed.',
+          schema: z.object({
+            keepLastN: z.number().optional().describe('Number of recent messages to keep (default 10, min 2).'),
+          }),
+        },
+      ),
+    )
+  }
+
+  return tools
+}

package/src/lib/server/session-tools/context.ts

@@ -0,0 +1,114 @@
+import type { StructuredToolInterface } from '@langchain/core/tools'
+
+export const MAX_OUTPUT = 50 * 1024 // 50KB
+export const MAX_FILE = 100 * 1024 // 100KB
+
+export interface ToolContext {
+  agentId?: string | null
+  sessionId?: string | null
+  platformAssignScope?: 'self' | 'all'
+  mcpServerIds?: string[]
+  mcpDisabledTools?: string[]
+}
+
+export interface SessionToolsResult {
+  tools: StructuredToolInterface[]
+  cleanup: () => Promise<void>
+}
+
+export interface ToolBuildContext {
+  cwd: string
+  ctx: ToolContext | undefined
+  hasTool: (name: string) => boolean
+  cleanupFns: (() => Promise<void>)[]
+  commandTimeoutMs: number
+  claudeTimeoutMs: number
+  cliProcessTimeoutMs: number
+  persistDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode', id: string | null | undefined) => void
+  readStoredDelegateResumeId: (key: 'claudeCode' | 'codex' | 'opencode') => string | null
+  resolveCurrentSession: () => any | null
+  activeTools: string[]
+}
+
+export function safePath(cwd: string, filePath: string): string {
+  const resolved = require('path').resolve(cwd, filePath)
+  if (!resolved.startsWith(require('path').resolve(cwd))) {
+    throw new Error('Path traversal not allowed')
+  }
+  return resolved
+}
+
+export function truncate(text: string, max: number): string {
+  if (text.length <= max) return text
+  return text.slice(0, max) + `\n... [truncated at ${max} bytes]`
+}
+
+export function tail(text: string, max = 4000): string {
+  if (!text) return ''
+  return text.length <= max ? text : text.slice(text.length - max)
+}
+
+export function extractResumeIdentifier(text: string): string | null {
+  if (!text) return null
+  const patterns = [
+    /session[_\s-]?id["'\s]*[:=]\s*["']?([A-Za-z0-9._:-]{6,})/i,
+    /thread[_\s-]?id["'\s]*[:=]\s*["']?([A-Za-z0-9._:-]{6,})/i,
+    /resume(?:\s+with)?\s+([A-Za-z0-9._:-]{6,})/i,
+  ]
+  for (const pattern of patterns) {
+    const m = text.match(pattern)
+    if (m?.[1]) return m[1]
+  }
+  return null
+}
+
+const binaryLookupCache = new Map<string, { checkedAt: number; path: string | null }>()
+const BINARY_LOOKUP_TTL_MS = 30_000
+
+export function findBinaryOnPath(binaryName: string): string | null {
+  const now = Date.now()
+  const cached = binaryLookupCache.get(binaryName)
+  if (cached && now - cached.checkedAt < BINARY_LOOKUP_TTL_MS) return cached.path
+
+  const { spawnSync } = require('child_process')
+  const probe = spawnSync('/bin/zsh', ['-lc', `command -v ${binaryName} 2>/dev/null`], {
+    encoding: 'utf-8',
+    timeout: 2000,
+  })
+  const resolved = (probe.stdout || '').trim() || null
+  binaryLookupCache.set(binaryName, { checkedAt: now, path: resolved })
+  return resolved
+}
+
+export function coerceEnvMap(value: unknown): Record<string, string> | undefined {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return undefined
+  const out: Record<string, string> = {}
+  for (const [k, v] of Object.entries(value as Record<string, unknown>)) {
+    if (typeof v === 'string') out[k] = v
+  }
+  return Object.keys(out).length ? out : undefined
+}
+
+export function listDirRecursive(dir: string, depth: number, maxDepth: number): string[] {
+  if (depth > maxDepth) return []
+  const fs = require('fs')
+  const path = require('path')
+  const entries: string[] = []
+  try {
+    const items = fs.readdirSync(dir, { withFileTypes: true })
+    for (const item of items) {
+      if (item.name.startsWith('.') || item.name === 'node_modules') continue
+      const rel = item.name
+      if (item.isDirectory()) {
+        entries.push(rel + '/')
+        const sub = listDirRecursive(path.join(dir, item.name), depth + 1, maxDepth)
+        entries.push(...sub.map((s: string) => `  ${rel}/${s}`))
+      } else {
+        entries.push(rel)
+      }
+    }
+  } catch {
+    // permission error etc
+  }
+  return entries
+}