@mojoaar/opencode-mimir 0.0.0-stage → 0.14.0

package/src/select.ts

@@ -0,0 +1,113 @@
+import { readdir, stat } from 'node:fs/promises'
+import { posix, join } from 'node:path'
+
+/**
+ * What an import is for: the knowledge a reader would have to dig out of the
+ * repository, not a second copy of the code the agent already has on disk.
+ */
+export const IGNORED_DIRS = new Set([
+  'node_modules',
+  '.git',
+  'dist',
+  'build',
+  '.next',
+  'coverage',
+  '.venv',
+  'venv',
+  '__pycache__',
+  '.idea',
+  '.vscode',
+  'vendor',
+  'target',
+  'tmp',
+])
+
+export const IGNORED_EXTENSIONS = new Set([
+  'png', 'jpg', 'jpeg', 'gif', 'webp', 'ico', 'pdf', 'zip', 'gz', 'tar', 'bz2', '7z', 'rar',
+  'exe', 'dll', 'so', 'dylib', 'o', 'a', 'class', 'jar', 'wasm',
+  'mp3', 'mp4', 'mov', 'avi', 'woff', 'woff2', 'ttf', 'eot',
+])
+
+const CONFIG_FILES = new Set([
+  'package.json',
+  'tsconfig.json',
+  'docker-compose.yml',
+  'docker-compose.yaml',
+  'compose.yml',
+  'compose.yaml',
+  'Dockerfile',
+  'Makefile',
+  'pyproject.toml',
+  'go.mod',
+  'Cargo.toml',
+  '.env.example',
+  'renovate.json',
+  'turbo.json',
+])
+
+const PROSE = /\.(md|mdx)$/i
+const ROOT_PROSE = /^(readme|changelog|contributing|license)/i
+// A guard against a symlinked home directory, not a product limit: a real
+// repository of 250 000 files is still walked, and hitting the cap is reported.
+const MAX_ENTRIES = 250_000
+
+export type WalkEntry = { path: string; bytes: number }
+export type WalkResult = {
+  files: WalkEntry[]
+  skipped: { path: string; reason: string }[]
+  /** True when the walk stopped early, so the caller must not report success. */
+  truncated: boolean
+}
+export type WalkOptions = { all?: boolean; maxFileBytes?: number; maxEntries?: number }
+
+function depth(path: string): number {
+  return path.split('/').length - 1
+}
+
+function wanted(path: string): boolean {
+  const base = posix.basename(path)
+  if (ROOT_PROSE.test(base) && depth(path) <= 1) return true
+  if (path.startsWith('docs/') || path.startsWith('doc/')) return PROSE.test(base)
+  if (PROSE.test(base) && depth(path) <= 3) return true
+  return CONFIG_FILES.has(base) && depth(path) <= 2
+}
+
+export async function selectFiles(root: string, options: WalkOptions = {}): Promise<WalkResult> {
+  const maxFileBytes = options.maxFileBytes ?? 262_144
+  const maxEntries = options.maxEntries ?? MAX_ENTRIES
+  const files: WalkEntry[] = []
+  const skipped: { path: string; reason: string }[] = []
+  let seen = 0
+  let truncated = false
+
+  async function walk(relative: string): Promise<void> {
+    const entries = await readdir(join(root, relative), { withFileTypes: true })
+    for (const entry of entries) {
+      if (++seen > maxEntries) {
+        truncated = true
+        return
+      }
+      const path = relative ? `${relative}/${entry.name}` : entry.name
+      if (entry.isDirectory()) {
+        if (IGNORED_DIRS.has(entry.name)) continue
+        await walk(path)
+        continue
+      }
+      if (!entry.isFile()) continue
+
+      const extension = posix.extname(entry.name).slice(1).toLowerCase()
+      if (IGNORED_EXTENSIONS.has(extension)) continue
+      if (options.all !== true && !wanted(path)) continue
+
+      const { size } = await stat(join(root, path))
+      if (size > maxFileBytes) {
+        skipped.push({ path, reason: `too large (${size} bytes)` })
+        continue
+      }
+      files.push({ path, bytes: size })
+    }
+  }
+
+  await walk('')
+  return { files, skipped, truncated }
+}

package/src/tools.ts

@@ -0,0 +1,123 @@
+import { callTool } from './client.js'
+import type { MimirConfig } from './config.js'
+
+export type Registration = { dispose: () => Promise<void> }
+
+type ToolExecutor = (input: any, context: any) => Promise<{ content: string }>
+type ToolDefinition = {
+  name: string
+  description: string
+  input: Record<string, unknown>
+  execute: ToolExecutor
+}
+
+type ToolsContext = {
+  tool: { transform: (callback: (editor: { add: (tool: ToolDefinition) => void }) => void) => Promise<Registration> }
+  mcp: {
+    transform: (
+      callback: (editor: { list: () => readonly [string, { type?: string; url?: string; disabled?: boolean }][] }) => void,
+    ) => Promise<Registration>
+  }
+}
+
+/**
+ * The two tools exist for someone running the plugin without the MCP server.
+ * When an MCP server already answers at the same endpoint they would only
+ * duplicate its tools, so `auto` leaves them out.
+ */
+export async function registerTools(
+  ctx: ToolsContext,
+  config: MimirConfig,
+  repo: string | null,
+): Promise<Registration> {
+  if (config.tools === 'never') return IDLE
+  if (config.tools === 'auto' && (await servedByMcp(ctx, config.url))) return IDLE
+
+  return ctx.tool.transform((editor) => {
+    editor.add(digestTool(repo))
+    editor.add(rememberTool(repo))
+  })
+}
+
+const IDLE: Registration = { dispose: async () => {} }
+
+async function servedByMcp(ctx: ToolsContext, url: string): Promise<boolean> {
+  let found = false
+  try {
+    const registration = await ctx.mcp.transform((editor) => {
+      found = editor
+        .list()
+        .some(([, server]) => server.type === 'remote' && !server.disabled && sameEndpoint(server.url, `${url}/mcp`))
+    })
+    await registration.dispose()
+  } catch {
+    // A broken MCP entry must not cost the session its tools.
+    return false
+  }
+  return found
+}
+
+function sameEndpoint(actual: string | undefined, expected: string): boolean {
+  return strip(actual) === strip(expected)
+}
+
+function strip(value: string | undefined): string {
+  return (value ?? '').replace(/\/+$/, '')
+}
+
+function digestTool(repo: string | null): ToolDefinition {
+  return {
+    name: 'mimir_digest',
+    description:
+      'Load what this project already knows from Mimir. Call once at the start of a session, before searching for anything.',
+    input: {
+      type: 'object',
+      properties: {
+        budget_tokens: {
+          type: 'integer',
+          minimum: 1,
+          description: 'Rough size cap, default 800',
+        },
+      },
+      additionalProperties: false,
+    },
+    async execute(input) {
+      const result = await callTool(
+        'memory_digest',
+        { budget_tokens: input?.budget_tokens ?? 800, repo: repo ?? undefined },
+        { timeoutMs: 5000 },
+      )
+      if (!result.ok) return { content: `Mimir is unavailable (${result.error}). Carry on without it.` }
+      const digest = result.result as { text?: string }
+      return { content: digest.text?.trim() || 'Mimir has nothing stored for this project yet.' }
+    },
+  }
+}
+
+function rememberTool(repo: string | null): ToolDefinition {
+  return {
+    name: 'mimir_remember',
+    description:
+      'Store one durable fact in Mimir. Use a path like "deploy/rollback" or "auth/token-rotation"; rewriting the same path replaces what was there.',
+    input: {
+      type: 'object',
+      properties: {
+        path: { type: 'string', description: 'Slash-separated memory path, e.g. deploy/rollback' },
+        body: { type: 'string', description: 'What to remember, written so it reads without the conversation' },
+        kind: { type: 'string', enum: ['note', 'fact', 'decision', 'gotcha', 'snippet'] },
+      },
+      required: ['path', 'body'],
+      additionalProperties: false,
+    },
+    async execute(input) {
+      const result = await callTool(
+        'memory_write',
+        { path: input.path, body: input.body, kind: input.kind, repo: repo ?? undefined },
+        { timeoutMs: 8000 },
+      )
+      if (!result.ok) return { content: `Could not store that (${result.error}).` }
+      const written = result.result as { path?: string; created?: boolean }
+      return { content: `${written.created ? 'Stored' : 'Updated'} ${written.path ?? input.path}.` }
+    },
+  }
+}