kimaki 0.26.0 → 0.28.0

package/src/session-search.test.ts

@@ -3,8 +3,13 @@
 import { describe, expect, test } from 'vitest'
 import {
   buildSessionSearchSnippet,
+  collectSessionSearchMatches,
   findFirstSessionSearchHit,
+  parseSessionSearchDays,
   parseSessionSearchPattern,
+  resolveSessionSearchDirectories,
+  sessionSearchMinUpdated,
+  validateSessionSearchScope,
 } from './session-search.js'
 
 describe('session search helpers', () => {
@@ -47,4 +52,280 @@ describe('session search helpers', () => {
       expect(snippet.toUpperCase()).toContain(expectedSubstring.toUpperCase())
     })
   })
+
+  test('rejects --all combined with --project or --channel', () => {
+    expect(
+      validateSessionSearchScope({ all: true, project: '/tmp/a' }),
+    ).toBeInstanceOf(Error)
+    expect(
+      validateSessionSearchScope({ all: true, channel: '123' }),
+    ).toBeInstanceOf(Error)
+    expect(validateSessionSearchScope({ all: true })).toBeNull()
+    expect(
+      validateSessionSearchScope({ project: '/tmp/a', channel: '123' }),
+    ).toBeInstanceOf(Error)
+  })
+
+  test('resolves --all to every registered project directory', () => {
+    const resolved = resolveSessionSearchDirectories({
+      all: true,
+      registeredDirectories: ['/tmp/kimaki', '/tmp/website', '/tmp/kimaki'],
+      cwd: '/tmp/current',
+    })
+    expect(resolved).toEqual(['/tmp/kimaki', '/tmp/website'])
+  })
+
+  test('returns error when --all has no registered projects', () => {
+    const resolved = resolveSessionSearchDirectories({
+      all: true,
+      registeredDirectories: [],
+      cwd: '/tmp/current',
+    })
+    expect(resolved).toBeInstanceOf(Error)
+  })
+
+  test('defaults to cwd or an explicit project when --all is off', () => {
+    expect(
+      resolveSessionSearchDirectories({
+        all: false,
+        cwd: '/tmp/current',
+        registeredDirectories: ['/tmp/kimaki'],
+      }),
+    ).toEqual(['/tmp/current'])
+    expect(
+      resolveSessionSearchDirectories({
+        all: false,
+        explicitDirectory: '/tmp/website',
+        cwd: '/tmp/current',
+        registeredDirectories: ['/tmp/kimaki'],
+      }),
+    ).toEqual(['/tmp/website'])
+  })
+
+  test('defaults --days to 14 and treats 0 as all time', () => {
+    expect(parseSessionSearchDays(undefined)).toBe(14)
+    expect(parseSessionSearchDays('0')).toBe(0)
+    expect(parseSessionSearchDays('7')).toBe(7)
+    expect(parseSessionSearchDays('-1')).toBeInstanceOf(Error)
+    expect(parseSessionSearchDays('nope')).toBeInstanceOf(Error)
+    expect(sessionSearchMinUpdated({ days: 0, now: 1_000 })).toBeUndefined()
+    expect(sessionSearchMinUpdated({ days: 14, now: 1_000 })).toBe(
+      1_000 - 14 * 24 * 60 * 60 * 1000,
+    )
+  })
+
+  test('skips sessions older than minUpdated without loading messages', async () => {
+    const parsed = parseSessionSearchPattern('auth timeout')
+    if (parsed instanceof Error) {
+      throw parsed
+    }
+
+    const now = 1_000_000_000_000
+    const minUpdated = now - 14 * 24 * 60 * 60 * 1000
+    const loaded: string[] = []
+    const result = await collectSessionSearchMatches({
+      sessions: [
+        {
+          id: 'ses_new',
+          title: 'new hit',
+          directory: '/tmp/kimaki',
+          updated: now,
+        },
+        {
+          id: 'ses_old',
+          title: 'old hit',
+          directory: '/tmp/website',
+          updated: minUpdated - 1,
+        },
+      ],
+      searchPattern: parsed,
+      sessionToThread: new Map(),
+      limit: 20,
+      minUpdated,
+      loadMessages: async (session) => {
+        loaded.push(session.id)
+        return [
+          {
+            info: { role: 'user' },
+            parts: [{ type: 'text', text: 'auth timeout', synthetic: false }],
+          },
+        ]
+      },
+    })
+
+    expect(loaded).toEqual(['ses_new'])
+    expect(result.scannedSessions).toBe(1)
+    expect(result.matches.map((match) => match.id)).toEqual(['ses_new'])
+  })
+
+  test('loads old matching sessions when minUpdated is unset', async () => {
+    const parsed = parseSessionSearchPattern('auth timeout')
+    if (parsed instanceof Error) {
+      throw parsed
+    }
+
+    const loaded: string[] = []
+    const result = await collectSessionSearchMatches({
+      sessions: [
+        {
+          id: 'ses_old',
+          title: 'old hit',
+          directory: '/tmp/website',
+          updated: 1,
+        },
+      ],
+      searchPattern: parsed,
+      sessionToThread: new Map(),
+      limit: 20,
+      loadMessages: async (session) => {
+        loaded.push(session.id)
+        return [
+          {
+            info: { role: 'user' },
+            parts: [{ type: 'text', text: 'auth timeout', synthetic: false }],
+          },
+        ]
+      },
+    })
+
+    expect(loaded).toEqual(['ses_old'])
+    expect(result.matches.map((match) => match.id)).toEqual(['ses_old'])
+  })
+
+  test('loads messages in parallel but keeps newest matches first', async () => {
+    const parsed = parseSessionSearchPattern('auth timeout')
+    if (parsed instanceof Error) {
+      throw parsed
+    }
+
+    let inFlight = 0
+    let maxInFlight = 0
+    const streamed: string[] = []
+    const result = await collectSessionSearchMatches({
+      sessions: [
+        {
+          id: 'ses_new',
+          title: 'new hit',
+          directory: '/tmp/kimaki',
+          updated: 3,
+        },
+        {
+          id: 'ses_mid',
+          title: 'mid hit',
+          directory: '/tmp/cli',
+          updated: 2,
+        },
+        {
+          id: 'ses_old',
+          title: 'old hit',
+          directory: '/tmp/website',
+          updated: 1,
+        },
+      ],
+      searchPattern: parsed,
+      sessionToThread: new Map(),
+      limit: 2,
+      concurrency: 3,
+      onMatch: (match) => {
+        streamed.push(match.id)
+      },
+      loadMessages: async (session) => {
+        inFlight++
+        maxInFlight = Math.max(maxInFlight, inFlight)
+        await new Promise((resolve) => {
+          setTimeout(resolve, session.id === 'ses_new' ? 40 : 5)
+        })
+        inFlight--
+        return [
+          {
+            info: { role: 'user' },
+            parts: [{ type: 'text', text: 'auth timeout', synthetic: false }],
+          },
+        ]
+      },
+    })
+
+    expect(maxInFlight).toBeGreaterThan(1)
+    expect(result.matches.map((match) => match.id)).toEqual([
+      'ses_new',
+      'ses_mid',
+    ])
+    expect(streamed).toEqual(['ses_new', 'ses_mid'])
+  })
+
+  test('collects newest matches across projects up to the global limit', async () => {
+    const parsed = parseSessionSearchPattern('auth timeout')
+    if (parsed instanceof Error) {
+      throw parsed
+    }
+
+    const result = await collectSessionSearchMatches({
+      sessions: [
+        {
+          id: 'ses_old',
+          title: 'old website hit',
+          directory: '/tmp/website',
+          updated: 1,
+          messages: [
+            {
+              info: { role: 'user' },
+              parts: [{ type: 'text', text: 'auth timeout on login', synthetic: false }],
+            },
+          ],
+        },
+        {
+          id: 'ses_new',
+          title: 'new kimaki hit',
+          directory: '/tmp/kimaki',
+          updated: 3,
+          messages: [
+            {
+              info: { role: 'assistant' },
+              parts: [{ type: 'text', text: 'fixed the auth timeout', synthetic: false }],
+            },
+          ],
+        },
+        {
+          id: 'ses_miss',
+          title: 'unrelated',
+          directory: '/tmp/cli',
+          updated: 4,
+          messages: [
+            {
+              info: { role: 'user' },
+              parts: [{ type: 'text', text: 'refactor logger', synthetic: false }],
+            },
+          ],
+        },
+        {
+          id: 'ses_mid',
+          title: 'mid cli hit',
+          directory: '/tmp/cli',
+          updated: 2,
+          messages: [
+            {
+              info: { role: 'user' },
+              parts: [{ type: 'text', text: 'auth timeout retry', synthetic: false }],
+            },
+          ],
+        },
+      ],
+      searchPattern: parsed,
+      sessionToThread: new Map([
+        ['ses_new', 'thread_new'],
+        ['ses_mid', 'thread_mid'],
+      ]),
+      limit: 2,
+      concurrency: 1,
+    })
+
+    expect(result.scannedSessions).toBe(3)
+    expect(result.matches.map((match) => match.id)).toEqual([
+      'ses_new',
+      'ses_mid',
+    ])
+    expect(result.matches[0]?.directory).toBe('/tmp/kimaki')
+    expect(result.matches[0]?.source).toBe('kimaki')
+    expect(result.matches[1]?.directory).toBe('/tmp/cli')
+  })
 })

package/src/session-search.ts

@@ -1,8 +1,6 @@
 // Session search helpers for kimaki CLI commands.
 // Parses string/regex queries and builds readable snippets from matched content.
 
-import type { Part } from '@opencode-ai/sdk/v2'
-
 export type SessionSearchPattern =
   | {
       mode: 'literal'
@@ -20,6 +18,48 @@ export type SessionSearchHit = {
   length: number
 }
 
+export type SessionSearchPart = {
+  type: string
+  synthetic?: boolean
+  text?: string
+  tool?: string
+  filename?: string
+  url?: string
+  state?: {
+    input?: unknown
+    status?: string
+    output?: unknown
+    error?: string
+  }
+}
+
+export type SessionSearchableMessage = {
+  info: { role: string }
+  parts: SessionSearchPart[]
+}
+
+export type SessionSearchableSession = {
+  id: string
+  title?: string
+  directory: string
+  updated: number
+  messages: SessionSearchableMessage[]
+}
+
+// Default window so search does not load years of old session messages.
+export const SESSION_SEARCH_DEFAULT_DAYS = 14
+export const SESSION_SEARCH_MESSAGE_CONCURRENCY = 4
+
+export type SessionSearchMatch = {
+  id: string
+  title: string
+  directory: string
+  updated: string
+  source: 'kimaki' | 'opencode'
+  threadId: string | null
+  snippets: string[]
+}
+
 export function parseSessionSearchPattern(
   query: string,
 ): SessionSearchPattern | Error {
@@ -120,21 +160,21 @@ function stringifyUnknown(value: unknown): string {
   }
 }
 
-export function getPartSearchTexts(part: Part): string[] {
+export function getPartSearchTexts(part: SessionSearchPart): string[] {
   switch (part.type) {
     case 'text':
       return part.text ? [part.text] : []
     case 'reasoning':
       return part.text ? [part.text] : []
     case 'tool': {
-      const inputText = stringifyUnknown(part.state.input)
+      const inputText = stringifyUnknown(part.state?.input)
       const outputText =
-        part.state.status === 'completed'
+        part.state?.status === 'completed'
           ? stringifyUnknown(part.state.output)
-          : part.state.status === 'error'
+          : part.state?.status === 'error'
             ? part.state.error || ''
             : ''
-      return [`tool:${part.tool}`, inputText, outputText].filter((entry) => {
+      return [`tool:${part.tool || ''}`, inputText, outputText].filter((entry) => {
         return entry.trim().length > 0
       })
     }
@@ -146,3 +186,197 @@ export function getPartSearchTexts(part: Part): string[] {
       return []
   }
 }
+
+export function validateSessionSearchScope({
+  all,
+  project,
+  channel,
+}: {
+  all?: boolean
+  project?: string
+  channel?: string
+}): Error | null {
+  if (all && (project || channel)) {
+    return new Error(
+      'Use --all alone. Do not combine it with --project or --channel. Search one project with: kimaki session search "query" --project /path',
+    )
+  }
+  if (project && channel) {
+    return new Error('Use either --project or --channel, not both')
+  }
+  return null
+}
+
+export function parseSessionSearchDays(raw: string | undefined): number | Error {
+  if (raw === undefined) {
+    return SESSION_SEARCH_DEFAULT_DAYS
+  }
+  const parsed = Number.parseInt(raw, 10)
+  if (Number.isNaN(parsed) || parsed < 0 || String(parsed) !== raw.trim()) {
+    return new Error(
+      `Invalid --days value: ${raw}. Use a whole number of days, or 0 for all time.`,
+    )
+  }
+  return parsed
+}
+
+export function sessionSearchMinUpdated({
+  days,
+  now = Date.now(),
+}: {
+  days: number
+  now?: number
+}): number | undefined {
+  if (days === 0) {
+    return undefined
+  }
+  return now - days * 24 * 60 * 60 * 1000
+}
+
+export function resolveSessionSearchDirectories({
+  all,
+  registeredDirectories,
+  cwd,
+  explicitDirectory,
+}: {
+  all: boolean
+  registeredDirectories: string[]
+  cwd: string
+  explicitDirectory?: string
+}): string[] | Error {
+  if (!all) {
+    return [explicitDirectory || cwd]
+  }
+
+  const uniqueDirectories = [...new Set(registeredDirectories)]
+  if (uniqueDirectories.length === 0) {
+    return new Error(
+      'No registered projects found. Add a project first with `kimaki project add`, or search one directory with --project.',
+    )
+  }
+  return uniqueDirectories
+}
+
+export function getSessionSearchSnippets({
+  messages,
+  searchPattern,
+}: {
+  messages: SessionSearchableMessage[]
+  searchPattern: SessionSearchPattern
+}): string[] {
+  return messages
+    .flatMap((message) => {
+      const rolePrefix =
+        message.info.role === 'assistant'
+          ? 'assistant'
+          : message.info.role === 'user'
+            ? 'user'
+            : 'message'
+
+      return message.parts
+        .filter((part) => !(part.type === 'text' && part.synthetic))
+        .flatMap((part) => {
+          return getPartSearchTexts(part).flatMap((text) => {
+            const hit = findFirstSessionSearchHit({
+              text,
+              searchPattern,
+            })
+            if (!hit) {
+              return []
+            }
+            const snippet = buildSessionSearchSnippet({ text, hit })
+            if (!snippet) {
+              return []
+            }
+            return [`${rolePrefix}: ${snippet}`]
+          })
+        })
+    })
+    .slice(0, 3)
+}
+
+export async function collectSessionSearchMatches({
+  sessions,
+  searchPattern,
+  sessionToThread,
+  limit,
+  minUpdated,
+  concurrency = SESSION_SEARCH_MESSAGE_CONCURRENCY,
+  loadMessages,
+  onMatch,
+}: {
+  sessions: Array<
+    Omit<SessionSearchableSession, 'messages'> & {
+      messages?: SessionSearchableMessage[]
+    }
+  >
+  searchPattern: SessionSearchPattern
+  sessionToThread: Map<string, string>
+  limit: number
+  minUpdated?: number
+  concurrency?: number
+  loadMessages?: (session: {
+    id: string
+    directory: string
+  }) => Promise<SessionSearchableMessage[]>
+  onMatch?: (match: SessionSearchMatch) => void
+}): Promise<{
+  matches: SessionSearchMatch[]
+  scannedSessions: number
+}> {
+  const sortedSessions = [...sessions]
+    .sort((a, b) => {
+      return b.updated - a.updated
+    })
+    .filter((session) => {
+      return minUpdated === undefined || session.updated >= minUpdated
+    })
+  const matches: SessionSearchMatch[] = []
+  let scannedSessions = 0
+  const batchSize = Math.max(1, concurrency)
+
+  for (let offset = 0; offset < sortedSessions.length; offset += batchSize) {
+    if (matches.length >= limit) {
+      break
+    }
+    const batch = sortedSessions.slice(offset, offset + batchSize)
+    scannedSessions += batch.length
+    const loadedBatch = await Promise.all(
+      batch.map(async (session) => {
+        const messages = session.messages
+          ? session.messages
+          : loadMessages
+            ? await loadMessages(session)
+            : []
+        return { session, messages }
+      }),
+    )
+    for (const { session, messages } of loadedBatch) {
+      if (matches.length >= limit) {
+        break
+      }
+      const snippets = getSessionSearchSnippets({
+        messages,
+        searchPattern,
+      })
+      if (snippets.length === 0) {
+        continue
+      }
+
+      const threadId = sessionToThread.get(session.id)
+      const match: SessionSearchMatch = {
+        id: session.id,
+        title: session.title || 'Untitled Session',
+        directory: session.directory,
+        updated: new Date(session.updated).toISOString(),
+        source: threadId ? 'kimaki' : 'opencode',
+        threadId: threadId || null,
+        snippets,
+      }
+      matches.push(match)
+      onMatch?.(match)
+    }
+  }
+
+  return { matches, scannedSessions }
+}