@hiai-gg/hiai-opencode 0.1.1 → 0.1.3

package/src/tools/session-manager/tools.ts

@@ -1,197 +1,197 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import {
-  SESSION_LIST_DESCRIPTION,
-  SESSION_READ_DESCRIPTION,
-  SESSION_SEARCH_DESCRIPTION,
-  SESSION_INFO_DESCRIPTION,
-} from "./constants"
-import { getAllSessions, getMainSessions, getSessionInfo, readSessionMessages, readSessionTodos, sessionExists, setStorageClient } from "./storage"
-import {
-  filterSessionsByDate,
-  formatSessionInfo,
-  formatSessionList,
-  formatSessionMessages,
-  formatSearchResults,
-  searchInSession,
-} from "./session-formatter"
-import type { SessionListArgs, SessionReadArgs, SessionSearchArgs, SessionInfoArgs, SearchResult } from "./types"
-
-const SEARCH_TIMEOUT_MS = 60_000
-const MAX_SESSIONS_TO_SCAN = 50
-
-function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
-  return Promise.race([
-    promise,
-    new Promise<T>((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms)),
-  ])
-}
-
-type SessionManagerToolDeps = {
-  getAllSessions: typeof getAllSessions
-  getMainSessions: typeof getMainSessions
-  getSessionInfo: typeof getSessionInfo
-  readSessionMessages: typeof readSessionMessages
-  readSessionTodos: typeof readSessionTodos
-  sessionExists: typeof sessionExists
-  setStorageClient: typeof setStorageClient
-  filterSessionsByDate: typeof filterSessionsByDate
-  formatSessionInfo: typeof formatSessionInfo
-  formatSessionList: typeof formatSessionList
-  formatSessionMessages: typeof formatSessionMessages
-  formatSearchResults: typeof formatSearchResults
-  searchInSession: typeof searchInSession
-}
-
-const defaultSessionManagerToolDeps: SessionManagerToolDeps = {
-  getAllSessions,
-  getMainSessions,
-  getSessionInfo,
-  readSessionMessages,
-  readSessionTodos,
-  sessionExists,
-  setStorageClient,
-  filterSessionsByDate,
-  formatSessionInfo,
-  formatSessionList,
-  formatSessionMessages,
-  formatSearchResults,
-  searchInSession,
-}
-
-export function createSessionManagerTools(
-  ctx: PluginInput,
-  deps: Partial<SessionManagerToolDeps> = {},
-): Record<string, ToolDefinition> {
-  const resolvedDeps: SessionManagerToolDeps = {
-    ...defaultSessionManagerToolDeps,
-    ...deps,
-  }
-  // Initialize storage client for SDK-based operations (beta mode)
-  resolvedDeps.setStorageClient(ctx.client)
-
-  const session_list: ToolDefinition = tool({
-    description: SESSION_LIST_DESCRIPTION,
-    args: {
-      limit: tool.schema.number().optional().describe("Maximum number of sessions to return"),
-      from_date: tool.schema.string().optional().describe("Filter sessions from this date (ISO 8601 format)"),
-      to_date: tool.schema.string().optional().describe("Filter sessions until this date (ISO 8601 format)"),
-      project_path: tool.schema.string().optional().describe("Filter sessions by project path (default: current working directory)"),
-    },
-    execute: async (args: SessionListArgs, _context) => {
-      try {
-        const directory = args.project_path ?? ctx.directory
-        let sessions = await resolvedDeps.getMainSessions({ directory })
-        let sessionIDs = sessions.map((s) => s.id)
-
-        if (args.from_date || args.to_date) {
-          sessionIDs = await resolvedDeps.filterSessionsByDate(sessionIDs, args.from_date, args.to_date)
-        }
-
-        if (args.limit && args.limit > 0) {
-          sessionIDs = sessionIDs.slice(0, args.limit)
-        }
-
-        return await resolvedDeps.formatSessionList(sessionIDs)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  const session_read: ToolDefinition = tool({
-    description: SESSION_READ_DESCRIPTION,
-    args: {
-      session_id: tool.schema.string().describe("Session ID to read"),
-      include_todos: tool.schema.boolean().optional().describe("Include todo list if available (default: false)"),
-      include_transcript: tool.schema.boolean().optional().describe("Include transcript log if available (default: false)"),
-      limit: tool.schema.number().optional().describe("Maximum number of messages to return (default: all)"),
-    },
-    execute: async (args: SessionReadArgs, _context) => {
-      try {
-        if (!(await resolvedDeps.sessionExists(args.session_id))) {
-          return `Session not found: ${args.session_id}`
-        }
-
-        let messages = await resolvedDeps.readSessionMessages(args.session_id)
-
-        if (messages.length === 0) {
-          return `Session not found: ${args.session_id}`
-        }
-
-        if (args.limit && args.limit > 0) {
-          messages = messages.slice(0, args.limit)
-        }
-
-        const todos = args.include_todos ? await resolvedDeps.readSessionTodos(args.session_id) : undefined
-
-        return resolvedDeps.formatSessionMessages(messages, args.include_todos, todos)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  const session_search: ToolDefinition = tool({
-    description: SESSION_SEARCH_DESCRIPTION,
-    args: {
-      query: tool.schema.string().describe("Search query string"),
-      session_id: tool.schema.string().optional().describe("Search within specific session only (default: all sessions)"),
-      case_sensitive: tool.schema.boolean().optional().describe("Case-sensitive search (default: false)"),
-      limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 20)"),
-    },
-    execute: async (args: SessionSearchArgs, _context) => {
-      try {
-        const resultLimit = args.limit && args.limit > 0 ? args.limit : 20
-
-        const searchOperation = async (): Promise<SearchResult[]> => {
-          if (args.session_id) {
-            return resolvedDeps.searchInSession(args.session_id, args.query, args.case_sensitive, resultLimit)
-          }
-
-          const allSessions = await resolvedDeps.getAllSessions()
-          const sessionsToScan = allSessions.slice(0, MAX_SESSIONS_TO_SCAN)
-
-          const allResults: SearchResult[] = []
-          for (const sid of sessionsToScan) {
-            if (allResults.length >= resultLimit) break
-
-            const remaining = resultLimit - allResults.length
-            const sessionResults = await resolvedDeps.searchInSession(sid, args.query, args.case_sensitive, remaining)
-            allResults.push(...sessionResults)
-          }
-
-          return allResults.slice(0, resultLimit)
-        }
-
-        const results = await withTimeout(searchOperation(), SEARCH_TIMEOUT_MS, "Search")
-
-        return resolvedDeps.formatSearchResults(results)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  const session_info: ToolDefinition = tool({
-    description: SESSION_INFO_DESCRIPTION,
-    args: {
-      session_id: tool.schema.string().describe("Session ID to inspect"),
-    },
-    execute: async (args: SessionInfoArgs, _context) => {
-      try {
-        const info = await resolvedDeps.getSessionInfo(args.session_id)
-
-        if (!info) {
-          return `Session not found: ${args.session_id}`
-        }
-
-        return resolvedDeps.formatSessionInfo(info)
-      } catch (e) {
-        return `Error: ${e instanceof Error ? e.message : String(e)}`
-      }
-    },
-  })
-
-  return { session_list, session_read, session_search, session_info }
-}
+import type { PluginInput } from "@opencode-ai/plugin"
+import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
+import {
+  SESSION_LIST_DESCRIPTION,
+  SESSION_READ_DESCRIPTION,
+  SESSION_SEARCH_DESCRIPTION,
+  SESSION_INFO_DESCRIPTION,
+} from "./constants"
+import { getAllSessions, getMainSessions, getSessionInfo, readSessionMessages, readSessionTodos, sessionExists, setStorageClient } from "./storage"
+import {
+  filterSessionsByDate,
+  formatSessionInfo,
+  formatSessionList,
+  formatSessionMessages,
+  formatSearchResults,
+  searchInSession,
+} from "./session-formatter"
+import type { SessionListArgs, SessionReadArgs, SessionSearchArgs, SessionInfoArgs, SearchResult } from "./types"
+
+const SEARCH_TIMEOUT_MS = 60_000
+const MAX_SESSIONS_TO_SCAN = 50
+
+function withTimeout<T>(promise: Promise<T>, ms: number, operation: string): Promise<T> {
+  return Promise.race([
+    promise,
+    new Promise<T>((_, reject) => setTimeout(() => reject(new Error(`${operation} timed out after ${ms}ms`)), ms)),
+  ])
+}
+
+type SessionManagerToolDeps = {
+  getAllSessions: typeof getAllSessions
+  getMainSessions: typeof getMainSessions
+  getSessionInfo: typeof getSessionInfo
+  readSessionMessages: typeof readSessionMessages
+  readSessionTodos: typeof readSessionTodos
+  sessionExists: typeof sessionExists
+  setStorageClient: typeof setStorageClient
+  filterSessionsByDate: typeof filterSessionsByDate
+  formatSessionInfo: typeof formatSessionInfo
+  formatSessionList: typeof formatSessionList
+  formatSessionMessages: typeof formatSessionMessages
+  formatSearchResults: typeof formatSearchResults
+  searchInSession: typeof searchInSession
+}
+
+const defaultSessionManagerToolDeps: SessionManagerToolDeps = {
+  getAllSessions,
+  getMainSessions,
+  getSessionInfo,
+  readSessionMessages,
+  readSessionTodos,
+  sessionExists,
+  setStorageClient,
+  filterSessionsByDate,
+  formatSessionInfo,
+  formatSessionList,
+  formatSessionMessages,
+  formatSearchResults,
+  searchInSession,
+}
+
+export function createSessionManagerTools(
+  ctx: PluginInput,
+  deps: Partial<SessionManagerToolDeps> = {},
+): Record<string, ToolDefinition> {
+  const resolvedDeps: SessionManagerToolDeps = {
+    ...defaultSessionManagerToolDeps,
+    ...deps,
+  }
+  // Initialize storage client for SDK-based operations (beta mode)
+  resolvedDeps.setStorageClient(ctx.client)
+
+  const session_list: ToolDefinition = tool({
+    description: SESSION_LIST_DESCRIPTION,
+    args: {
+      limit: tool.schema.number().optional().describe("Maximum number of sessions to return"),
+      from_date: tool.schema.string().optional().describe("Filter sessions from this date (ISO 8601 format)"),
+      to_date: tool.schema.string().optional().describe("Filter sessions until this date (ISO 8601 format)"),
+      project_path: tool.schema.string().optional().describe("Filter sessions by project path (default: current working directory)"),
+    },
+    execute: async (args: SessionListArgs, _context) => {
+      try {
+        const directory = args.project_path ?? ctx.directory
+        let sessions = await resolvedDeps.getMainSessions({ directory })
+        let sessionIDs = sessions.map((s) => s.id)
+
+        if (args.from_date || args.to_date) {
+          sessionIDs = await resolvedDeps.filterSessionsByDate(sessionIDs, args.from_date, args.to_date)
+        }
+
+        if (args.limit && args.limit > 0) {
+          sessionIDs = sessionIDs.slice(0, args.limit)
+        }
+
+        return await resolvedDeps.formatSessionList(sessionIDs)
+      } catch (e) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`
+      }
+    },
+  })
+
+  const session_read: ToolDefinition = tool({
+    description: SESSION_READ_DESCRIPTION,
+    args: {
+      session_id: tool.schema.string().describe("Session ID to read"),
+      include_todos: tool.schema.boolean().optional().describe("Include todo list if available (default: false)"),
+      include_transcript: tool.schema.boolean().optional().describe("Include transcript log if available (default: false)"),
+      limit: tool.schema.number().optional().describe("Maximum number of messages to return (default: all)"),
+    },
+    execute: async (args: SessionReadArgs, _context) => {
+      try {
+        if (!(await resolvedDeps.sessionExists(args.session_id))) {
+          return `Session not found: ${args.session_id}`
+        }
+
+        let messages = await resolvedDeps.readSessionMessages(args.session_id)
+
+        if (messages.length === 0) {
+          return `Session not found: ${args.session_id}`
+        }
+
+        if (args.limit && args.limit > 0) {
+          messages = messages.slice(0, args.limit)
+        }
+
+        const todos = args.include_todos ? await resolvedDeps.readSessionTodos(args.session_id) : undefined
+
+        return resolvedDeps.formatSessionMessages(messages, args.include_todos, todos)
+      } catch (e) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`
+      }
+    },
+  })
+
+  const session_search: ToolDefinition = tool({
+    description: SESSION_SEARCH_DESCRIPTION,
+    args: {
+      query: tool.schema.string().describe("Search query string"),
+      session_id: tool.schema.string().optional().describe("Search within specific session only (default: all sessions)"),
+      case_sensitive: tool.schema.boolean().optional().describe("Case-sensitive search (default: false)"),
+      limit: tool.schema.number().optional().describe("Maximum number of results to return (default: 20)"),
+    },
+    execute: async (args: SessionSearchArgs, _context) => {
+      try {
+        const resultLimit = args.limit && args.limit > 0 ? args.limit : 20
+
+        const searchOperation = async (): Promise<SearchResult[]> => {
+          if (args.session_id) {
+            return resolvedDeps.searchInSession(args.session_id, args.query, args.case_sensitive, resultLimit)
+          }
+
+          const allSessions = await resolvedDeps.getAllSessions()
+          const sessionsToScan = allSessions.slice(0, MAX_SESSIONS_TO_SCAN)
+
+          const allResults: SearchResult[] = []
+          for (const sid of sessionsToScan) {
+            if (allResults.length >= resultLimit) break
+
+            const remaining = resultLimit - allResults.length
+            const sessionResults = await resolvedDeps.searchInSession(sid, args.query, args.case_sensitive, remaining)
+            allResults.push(...sessionResults)
+          }
+
+          return allResults.slice(0, resultLimit)
+        }
+
+        const results = await withTimeout(searchOperation(), SEARCH_TIMEOUT_MS, "Search")
+
+        return resolvedDeps.formatSearchResults(results)
+      } catch (e) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`
+      }
+    },
+  })
+
+  const session_info: ToolDefinition = tool({
+    description: SESSION_INFO_DESCRIPTION,
+    args: {
+      session_id: tool.schema.string().describe("Session ID to inspect"),
+    },
+    execute: async (args: SessionInfoArgs, _context) => {
+      try {
+        const info = await resolvedDeps.getSessionInfo(args.session_id)
+
+        if (!info) {
+          return `Session not found: ${args.session_id}`
+        }
+
+        return resolvedDeps.formatSessionInfo(info)
+      } catch (e) {
+        return `Error: ${e instanceof Error ? e.message : String(e)}`
+      }
+    },
+  })
+
+  return { session_list, session_read, session_search, session_info }
+}

package/src/tools/session-manager/types.ts

@@ -1,99 +1,99 @@
-export interface SessionMessage {
-  id: string
-  role: "user" | "assistant"
-  agent?: string
-  time?: {
-    created: number
-    updated?: number
-  }
-  parts: MessagePart[]
-}
-
-export interface MessagePart {
-  id: string
-  type: string
-  text?: string
-  thinking?: string
-  tool?: string
-  callID?: string
-  input?: Record<string, unknown>
-  output?: string
-  error?: string
-}
-
-export interface SessionInfo {
-  id: string
-  message_count: number
-  first_message?: Date
-  last_message?: Date
-  agents_used: string[]
-  has_todos: boolean
-  has_transcript: boolean
-  todos?: TodoItem[]
-  transcript_entries?: number
-}
-
-export interface TodoItem {
-  id?: string;
-  content: string;
-  status: "pending" | "in_progress" | "completed" | "cancelled";
-  priority?: string;
-}
-
-export interface SearchResult {
-  session_id: string
-  message_id: string
-  role: string
-  excerpt: string
-  match_count: number
-  timestamp?: number
-}
-
-export interface SessionMetadata {
-  id: string
-  version?: string
-  projectID: string
-  directory: string
-  title?: string
-  parentID?: string
-  time: {
-    created: number
-    updated: number
-  }
-  summary?: {
-    additions: number
-    deletions: number
-    files: number
-  }
-}
-
-export interface SessionListArgs {
-  limit?: number
-  offset?: number
-  from_date?: string
-  to_date?: string
-  project_path?: string
-}
-
-export interface SessionReadArgs {
-  session_id: string
-  include_todos?: boolean
-  include_transcript?: boolean
-  limit?: number
-}
-
-export interface SessionSearchArgs {
-  query: string
-  session_id?: string
-  case_sensitive?: boolean
-  limit?: number
-}
-
-export interface SessionInfoArgs {
-  session_id: string
-}
-
-export interface SessionDeleteArgs {
-  session_id: string
-  confirm: boolean
-}
+export interface SessionMessage {
+  id: string
+  role: "user" | "assistant"
+  agent?: string
+  time?: {
+    created: number
+    updated?: number
+  }
+  parts: MessagePart[]
+}
+
+export interface MessagePart {
+  id: string
+  type: string
+  text?: string
+  thinking?: string
+  tool?: string
+  callID?: string
+  input?: Record<string, unknown>
+  output?: string
+  error?: string
+}
+
+export interface SessionInfo {
+  id: string
+  message_count: number
+  first_message?: Date
+  last_message?: Date
+  agents_used: string[]
+  has_todos: boolean
+  has_transcript: boolean
+  todos?: TodoItem[]
+  transcript_entries?: number
+}
+
+export interface TodoItem {
+  id?: string;
+  content: string;
+  status: "pending" | "in_progress" | "completed" | "cancelled";
+  priority?: string;
+}
+
+export interface SearchResult {
+  session_id: string
+  message_id: string
+  role: string
+  excerpt: string
+  match_count: number
+  timestamp?: number
+}
+
+export interface SessionMetadata {
+  id: string
+  version?: string
+  projectID: string
+  directory: string
+  title?: string
+  parentID?: string
+  time: {
+    created: number
+    updated: number
+  }
+  summary?: {
+    additions: number
+    deletions: number
+    files: number
+  }
+}
+
+export interface SessionListArgs {
+  limit?: number
+  offset?: number
+  from_date?: string
+  to_date?: string
+  project_path?: string
+}
+
+export interface SessionReadArgs {
+  session_id: string
+  include_todos?: boolean
+  include_transcript?: boolean
+  limit?: number
+}
+
+export interface SessionSearchArgs {
+  query: string
+  session_id?: string
+  case_sensitive?: boolean
+  limit?: number
+}
+
+export interface SessionInfoArgs {
+  session_id: string
+}
+
+export interface SessionDeleteArgs {
+  session_id: string
+  confirm: boolean
+}

package/src/tools/shared/semaphore.ts

@@ -1,32 +1,32 @@
-/**
- * Simple counting semaphore to limit concurrent process execution.
- * Used to prevent multiple ripgrep processes from saturating CPU.
- */
-export class Semaphore {
-  private queue: (() => void)[] = []
-  private running = 0
-
-  constructor(private readonly max: number) {}
-
-  async acquire(): Promise<void> {
-    if (this.running < this.max) {
-      this.running++
-      return
-    }
-    return new Promise<void>((resolve) => {
-      this.queue.push(() => {
-        this.running++
-        resolve()
-      })
-    })
-  }
-
-  release(): void {
-    this.running--
-    const next = this.queue.shift()
-    if (next) next()
-  }
-}
-
-/** Global semaphore limiting concurrent ripgrep processes to 2 */
-export const rgSemaphore = new Semaphore(2)
+/**
+ * Simple counting semaphore to limit concurrent process execution.
+ * Used to prevent multiple ripgrep processes from saturating CPU.
+ */
+export class Semaphore {
+  private queue: (() => void)[] = []
+  private running = 0
+
+  constructor(private readonly max: number) {}
+
+  async acquire(): Promise<void> {
+    if (this.running < this.max) {
+      this.running++
+      return
+    }
+    return new Promise<void>((resolve) => {
+      this.queue.push(() => {
+        this.running++
+        resolve()
+      })
+    })
+  }
+
+  release(): void {
+    this.running--
+    const next = this.queue.shift()
+    if (next) next()
+  }
+}
+
+/** Global semaphore limiting concurrent ripgrep processes to 2 */
+export const rgSemaphore = new Semaphore(2)