@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/tools/lsp/symbols-tool.ts

@@ -1,76 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-
-import { DEFAULT_MAX_SYMBOLS } from "./constants"
-import { formatDocumentSymbol, formatSymbolInfo } from "./lsp-formatters"
-import { withLspClient } from "./lsp-client-wrapper"
-import type { DocumentSymbol, SymbolInfo } from "./types"
-
-export const lsp_symbols: ToolDefinition = tool({
-  description:
-    "Get symbols from file (document) or search across workspace. Use scope='document' for file outline, scope='workspace' for project-wide symbol search.",
-  args: {
-    filePath: tool.schema.string().describe("File path for LSP context"),
-    scope: tool.schema
-      .enum(["document", "workspace"])
-      .default("document")
-      .describe("'document' for file symbols, 'workspace' for project-wide search"),
-    query: tool.schema.string().optional().describe("Symbol name to search (required for workspace scope)"),
-    limit: tool.schema.number().optional().describe("Max results (default 50)"),
-  },
-  execute: async (args, _context) => {
-    try {
-      const scope = args.scope ?? "document"
-
-      if (scope === "workspace") {
-        if (!args.query) {
-          return "Error: 'query' is required for workspace scope"
-        }
-
-        const result = await withLspClient(args.filePath, async (client) => {
-          return (await client.workspaceSymbols(args.query!)) as SymbolInfo[] | null
-        })
-
-        if (!result || result.length === 0) {
-          return "No symbols found"
-        }
-
-        const total = result.length
-        const limit = Math.min(args.limit ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS)
-        const truncated = total > limit
-        const limited = result.slice(0, limit)
-        const lines = limited.map(formatSymbolInfo)
-        if (truncated) {
-          lines.unshift(`Found ${total} symbols (showing first ${limit}):`)
-        }
-        return lines.join("\n")
-      } else {
-        const result = await withLspClient(args.filePath, async (client) => {
-          return (await client.documentSymbols(args.filePath)) as DocumentSymbol[] | SymbolInfo[] | null
-        })
-
-        if (!result || result.length === 0) {
-          return "No symbols found"
-        }
-
-        const total = result.length
-        const limit = Math.min(args.limit ?? DEFAULT_MAX_SYMBOLS, DEFAULT_MAX_SYMBOLS)
-        const truncated = total > limit
-        const limited = truncated ? result.slice(0, limit) : result
-
-        const lines: string[] = []
-        if (truncated) {
-          lines.push(`Found ${total} symbols (showing first ${limit}):`)
-        }
-
-        if ("range" in limited[0]) {
-          lines.push(...(limited as DocumentSymbol[]).map((s) => formatDocumentSymbol(s)))
-        } else {
-          lines.push(...(limited as SymbolInfo[]).map(formatSymbolInfo))
-        }
-        return lines.join("\n")
-      }
-    } catch (e) {
-      return `Error: ${e instanceof Error ? e.message : String(e)}`
-    }
-  },
-})

package/src/tools/lsp/tools.ts

@@ -1,5 +0,0 @@
-export { lsp_goto_definition } from "./goto-definition-tool"
-export { lsp_find_references } from "./find-references-tool"
-export { lsp_symbols } from "./symbols-tool"
-export { lsp_diagnostics } from "./diagnostics-tool"
-export { lsp_prepare_rename, lsp_rename } from "./rename-tools"

package/src/tools/lsp/types.ts

@@ -1,124 +0,0 @@
-export interface LSPServerConfig {
-  id: string
-  command: string[]
-  extensions: string[]
-  disabled?: boolean
-  env?: Record<string, string>
-  initialization?: Record<string, unknown>
-}
-
-export interface Position {
-  line: number
-  character: number
-}
-
-export interface Range {
-  start: Position
-  end: Position
-}
-
-export interface Location {
-  uri: string
-  range: Range
-}
-
-export interface LocationLink {
-  targetUri: string
-  targetRange: Range
-  targetSelectionRange: Range
-  originSelectionRange?: Range
-}
-
-export interface SymbolInfo {
-  name: string
-  kind: number
-  location: Location
-  containerName?: string
-}
-
-export interface DocumentSymbol {
-  name: string
-  kind: number
-  range: Range
-  selectionRange: Range
-  children?: DocumentSymbol[]
-}
-
-export interface Diagnostic {
-  range: Range
-  severity?: number
-  code?: string | number
-  source?: string
-  message: string
-}
-
-export interface TextDocumentIdentifier {
-  uri: string
-}
-
-export interface VersionedTextDocumentIdentifier extends TextDocumentIdentifier {
-  version: number | null
-}
-
-export interface TextEdit {
-  range: Range
-  newText: string
-}
-
-export interface TextDocumentEdit {
-  textDocument: VersionedTextDocumentIdentifier
-  edits: TextEdit[]
-}
-
-export interface CreateFile {
-  kind: "create"
-  uri: string
-  options?: { overwrite?: boolean; ignoreIfExists?: boolean }
-}
-
-export interface RenameFile {
-  kind: "rename"
-  oldUri: string
-  newUri: string
-  options?: { overwrite?: boolean; ignoreIfExists?: boolean }
-}
-
-export interface DeleteFile {
-  kind: "delete"
-  uri: string
-  options?: { recursive?: boolean; ignoreIfNotExists?: boolean }
-}
-
-export interface WorkspaceEdit {
-  changes?: { [uri: string]: TextEdit[] }
-  documentChanges?: (TextDocumentEdit | CreateFile | RenameFile | DeleteFile)[]
-}
-
-export interface PrepareRenameResult {
-  range: Range
-  placeholder?: string
-}
-
-export interface PrepareRenameDefaultBehavior {
-  defaultBehavior: boolean
-}
-
-export interface ServerLookupInfo {
-  id: string
-  command: string[]
-  extensions: string[]
-}
-
-export type ServerLookupResult =
-  | { status: "found"; server: ResolvedServer }
-  | { status: "not_configured"; extension: string; availableServers: string[] }
-  | { status: "not_installed"; server: ServerLookupInfo; installHint: string }
-
-export interface ResolvedServer {
-  id: string
-  command: string[]
-  extensions: string[]
-  priority: number
-  env?: Record<string, string>
-  initialization?: Record<string, unknown>
-}

package/src/tools/lsp/workspace-edit.ts

@@ -1,121 +0,0 @@
-import { readFileSync, writeFileSync } from "fs"
-
-import { uriToPath } from "./lsp-client-wrapper"
-import type { TextEdit, WorkspaceEdit } from "./types"
-
-export interface ApplyResult {
-  success: boolean
-  filesModified: string[]
-  totalEdits: number
-  errors: string[]
-}
-
-function applyTextEditsToFile(filePath: string, edits: TextEdit[]): { success: boolean; editCount: number; error?: string } {
-  try {
-    let content = readFileSync(filePath, "utf-8")
-    const lines = content.split("\n")
-
-    const sortedEdits = [...edits].sort((a, b) => {
-      if (b.range.start.line !== a.range.start.line) {
-        return b.range.start.line - a.range.start.line
-      }
-      return b.range.start.character - a.range.start.character
-    })
-
-    for (const edit of sortedEdits) {
-      const startLine = edit.range.start.line
-      const startChar = edit.range.start.character
-      const endLine = edit.range.end.line
-      const endChar = edit.range.end.character
-
-      if (startLine === endLine) {
-        const line = lines[startLine] || ""
-        lines[startLine] = line.substring(0, startChar) + edit.newText + line.substring(endChar)
-      } else {
-        const firstLine = lines[startLine] || ""
-        const lastLine = lines[endLine] || ""
-        const newContent = firstLine.substring(0, startChar) + edit.newText + lastLine.substring(endChar)
-        lines.splice(startLine, endLine - startLine + 1, ...newContent.split("\n"))
-      }
-    }
-
-    writeFileSync(filePath, lines.join("\n"), "utf-8")
-    return { success: true, editCount: edits.length }
-  } catch (err) {
-    return { success: false, editCount: 0, error: err instanceof Error ? err.message : String(err) }
-  }
-}
-
-export function applyWorkspaceEdit(edit: WorkspaceEdit | null): ApplyResult {
-  if (!edit) {
-    return { success: false, filesModified: [], totalEdits: 0, errors: ["No edit provided"] }
-  }
-
-  const result: ApplyResult = { success: true, filesModified: [], totalEdits: 0, errors: [] }
-
-  if (edit.changes) {
-    for (const [uri, edits] of Object.entries(edit.changes)) {
-      const filePath = uriToPath(uri)
-      const applyResult = applyTextEditsToFile(filePath, edits)
-
-      if (applyResult.success) {
-        result.filesModified.push(filePath)
-        result.totalEdits += applyResult.editCount
-      } else {
-        result.success = false
-        result.errors.push(`${filePath}: ${applyResult.error}`)
-      }
-    }
-  }
-
-  if (edit.documentChanges) {
-    for (const change of edit.documentChanges) {
-      if ("kind" in change) {
-        if (change.kind === "create") {
-          try {
-            const filePath = uriToPath(change.uri)
-            writeFileSync(filePath, "", "utf-8")
-            result.filesModified.push(filePath)
-          } catch (err) {
-            result.success = false
-            result.errors.push(`Create ${change.uri}: ${err}`)
-          }
-        } else if (change.kind === "rename") {
-          try {
-            const oldPath = uriToPath(change.oldUri)
-            const newPath = uriToPath(change.newUri)
-            const content = readFileSync(oldPath, "utf-8")
-            writeFileSync(newPath, content, "utf-8")
-            require("fs").unlinkSync(oldPath)
-            result.filesModified.push(newPath)
-          } catch (err) {
-            result.success = false
-            result.errors.push(`Rename ${change.oldUri}: ${err}`)
-          }
-        } else if (change.kind === "delete") {
-          try {
-            const filePath = uriToPath(change.uri)
-            require("fs").unlinkSync(filePath)
-            result.filesModified.push(filePath)
-          } catch (err) {
-            result.success = false
-            result.errors.push(`Delete ${change.uri}: ${err}`)
-          }
-        }
-      } else {
-        const filePath = uriToPath(change.textDocument.uri)
-        const applyResult = applyTextEditsToFile(filePath, change.edits)
-
-        if (applyResult.success) {
-          result.filesModified.push(filePath)
-          result.totalEdits += applyResult.editCount
-        } else {
-          result.success = false
-          result.errors.push(`${filePath}: ${applyResult.error}`)
-        }
-      }
-    }
-  }
-
-  return result
-}

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

@@ -1,93 +0,0 @@
-import { join } from "node:path"
-import { getClaudeConfigDir } from "../../shared"
-
-export { OPENCODE_STORAGE, MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE } from "../../shared"
-export const TODO_DIR = join(getClaudeConfigDir(), "todos")
-export const TRANSCRIPT_DIR = join(getClaudeConfigDir(), "transcripts")
-export const SESSION_LIST_DESCRIPTION = `List all OpenCode sessions with optional filtering.
-
-Returns a list of available session IDs with metadata including message count, date range, and agents used.
-
-Arguments:
-- limit (optional): Maximum number of sessions to return
-- from_date (optional): Filter sessions from this date (ISO 8601 format)
-- to_date (optional): Filter sessions until this date (ISO 8601 format)
-
-Example output:
-| Session ID | Messages | First | Last | Agents |
-|------------|----------|-------|------|--------|
-| ses_abc123 | 45 | 2025-12-20 | 2025-12-24 | bob, strategist |
-| ses_def456 | 12 | 2025-12-19 | 2025-12-19 | bob |`
-
-export const SESSION_READ_DESCRIPTION = `Read messages and history from an OpenCode session.
-
-Returns a formatted view of session messages with role, timestamp, and content. Optionally includes todos and transcript data.
-
-Arguments:
-- session_id (required): Session ID to read
-- include_todos (optional): Include todo list if available (default: false)
-- include_transcript (optional): Include transcript log if available (default: false)
-- limit (optional): Maximum number of messages to return (default: all)
-
-Example output:
-Session: ses_abc123
-Messages: 45
-Date Range: 2025-12-20 to 2025-12-24
-
-[Message 1] user (2025-12-20 10:30:00)
-Hello, can you help me with...
-
-[Message 2] assistant (2025-12-20 10:30:15)
-Of course! Let me help you with...`
-
-export const SESSION_SEARCH_DESCRIPTION = `Search for content within OpenCode session messages.
-
-Performs full-text search across session messages and returns matching excerpts with context.
-
-Arguments:
-- query (required): Search query string
-- session_id (optional): Search within specific session only (default: all sessions)
-- case_sensitive (optional): Case-sensitive search (default: false)
-- limit (optional): Maximum number of results to return (default: 20)
-
-Example output:
-Found 3 matches across 2 sessions:
-
-[ses_abc123] Message msg_001 (user)
-...implement the **session manager** tool...
-
-[ses_abc123] Message msg_005 (assistant)
-...I'll create a **session manager** with full search...
-
-[ses_def456] Message msg_012 (user)
-...use the **session manager** to find...`
-
-export const SESSION_INFO_DESCRIPTION = `Get metadata and statistics about an OpenCode session.
-
-Returns detailed information about a session including message count, date range, agents used, and available data sources.
-
-Arguments:
-- session_id (required): Session ID to inspect
-
-Example output:
-Session ID: ses_abc123
-Messages: 45
-Date Range: 2025-12-20 10:30:00 to 2025-12-24 15:45:30
-Duration: 4 days, 5 hours
-Agents Used: bob, strategist, researcher
-Has Todos: Yes (12 items, 8 completed)
-Has Transcript: Yes (234 entries)`
-
-export const SESSION_DELETE_DESCRIPTION = `Delete an OpenCode session and all associated data.
-
-Removes session messages, parts, todos, and transcript. This operation cannot be undone.
-
-Arguments:
-- session_id (required): Session ID to delete
-- confirm (required): Must be true to confirm deletion
-
-Example:
-session_delete(session_id="ses_abc123", confirm=true)
-Successfully deleted session ses_abc123`
-
-export const TOOL_NAME_PREFIX = "session_"

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

@@ -1,203 +0,0 @@
-import { existsSync } from "node:fs"
-import { readdir, readFile } from "node:fs/promises"
-import { join } from "node:path"
-import { MESSAGE_STORAGE, PART_STORAGE, SESSION_STORAGE, TODO_DIR, TRANSCRIPT_DIR } from "./constants"
-import { getMessageDir } from "../../shared/opencode-message-dir"
-import type { SessionInfo, SessionMessage, SessionMetadata, TodoItem } from "./types"
-
-export async function getFileMainSessions(directory?: string): Promise<SessionMetadata[]> {
-  if (!existsSync(SESSION_STORAGE)) return []
-
-  const sessions: SessionMetadata[] = []
-
-  try {
-    const projectDirs = await readdir(SESSION_STORAGE, { withFileTypes: true })
-    for (const projectDir of projectDirs) {
-      if (!projectDir.isDirectory()) continue
-      const projectPath = join(SESSION_STORAGE, projectDir.name)
-      const sessionFiles = await readdir(projectPath)
-
-      for (const file of sessionFiles) {
-        if (!file.endsWith(".json")) continue
-
-        try {
-          const content = await readFile(join(projectPath, file), "utf-8")
-          const meta = JSON.parse(content) as SessionMetadata
-          if (meta.parentID) continue
-          if (directory && meta.directory !== directory) continue
-          sessions.push(meta)
-        } catch {
-          continue
-        }
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return sessions.sort((a, b) => b.time.updated - a.time.updated)
-}
-
-export async function getFileAllSessions(): Promise<string[]> {
-  if (!existsSync(MESSAGE_STORAGE)) return []
-
-  const sessions: string[] = []
-
-  async function scanDirectory(dir: string): Promise<void> {
-    try {
-      const entries = await readdir(dir, { withFileTypes: true })
-      for (const entry of entries) {
-        if (!entry.isDirectory()) continue
-        const sessionPath = join(dir, entry.name)
-        const files = await readdir(sessionPath)
-        if (files.some((file) => file.endsWith(".json"))) {
-          sessions.push(entry.name)
-          continue
-        }
-        await scanDirectory(sessionPath)
-      }
-    } catch {
-      return
-    }
-  }
-
-  await scanDirectory(MESSAGE_STORAGE)
-  return [...new Set(sessions)]
-}
-
-export async function fileSessionExists(sessionID: string): Promise<boolean> {
-  return getMessageDir(sessionID) !== null
-}
-
-export async function getFileSessionMessages(sessionID: string): Promise<SessionMessage[]> {
-  const messageDir = getMessageDir(sessionID)
-  if (!messageDir || !existsSync(messageDir)) return []
-
-  const messages: SessionMessage[] = []
-  try {
-    const files = await readdir(messageDir)
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue
-      try {
-        const content = await readFile(join(messageDir, file), "utf-8")
-        const meta = JSON.parse(content)
-        const parts = await readParts(meta.id)
-        messages.push({
-          id: meta.id,
-          role: meta.role,
-          agent: meta.agent,
-          time: meta.time,
-          parts,
-        })
-      } catch {
-        continue
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return messages.sort((a, b) => {
-    const aTime = a.time?.created ?? 0
-    const bTime = b.time?.created ?? 0
-    if (aTime !== bTime) return aTime - bTime
-    return a.id.localeCompare(b.id)
-  })
-}
-
-async function readParts(messageID: string): Promise<Array<{ id: string; type: string; [key: string]: unknown }>> {
-  const partDir = join(PART_STORAGE, messageID)
-  if (!existsSync(partDir)) return []
-
-  const parts: Array<{ id: string; type: string; [key: string]: unknown }> = []
-  try {
-    const files = await readdir(partDir)
-    for (const file of files) {
-      if (!file.endsWith(".json")) continue
-      try {
-        const content = await readFile(join(partDir, file), "utf-8")
-        parts.push(JSON.parse(content))
-      } catch {
-        continue
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return parts.sort((a, b) => a.id.localeCompare(b.id))
-}
-
-export async function getFileSessionTodos(sessionID: string): Promise<TodoItem[]> {
-  if (!existsSync(TODO_DIR)) return []
-
-  try {
-    const allFiles = await readdir(TODO_DIR)
-    const todoFiles = allFiles.filter((file) => file === `${sessionID}.json`)
-
-    for (const file of todoFiles) {
-      try {
-        const content = await readFile(join(TODO_DIR, file), "utf-8")
-        const data = JSON.parse(content)
-        if (!Array.isArray(data)) continue
-        return data.map((item) => ({
-          id: item.id || "",
-          content: item.content || "",
-          status: item.status || "pending",
-          priority: item.priority,
-        }))
-      } catch {
-        continue
-      }
-    }
-  } catch {
-    return []
-  }
-
-  return []
-}
-
-export async function getFileSessionTranscript(sessionID: string): Promise<number> {
-  if (!existsSync(TRANSCRIPT_DIR)) return 0
-  const transcriptFile = join(TRANSCRIPT_DIR, `${sessionID}.jsonl`)
-  if (!existsSync(transcriptFile)) return 0
-
-  try {
-    const content = await readFile(transcriptFile, "utf-8")
-    return content.trim().split("\n").filter(Boolean).length
-  } catch {
-    return 0
-  }
-}
-
-export async function getFileSessionInfo(sessionID: string): Promise<SessionInfo | null> {
-  const messages = await getFileSessionMessages(sessionID)
-  if (messages.length === 0) return null
-
-  const agentsUsed = new Set<string>()
-  let firstMessage: Date | undefined
-  let lastMessage: Date | undefined
-
-  for (const msg of messages) {
-    if (msg.agent) agentsUsed.add(msg.agent)
-    if (!msg.time?.created) continue
-    const date = new Date(msg.time.created)
-    if (!firstMessage || date < firstMessage) firstMessage = date
-    if (!lastMessage || date > lastMessage) lastMessage = date
-  }
-
-  const todos = await getFileSessionTodos(sessionID)
-  const transcriptEntries = await getFileSessionTranscript(sessionID)
-
-  return {
-    id: sessionID,
-    message_count: messages.length,
-    first_message: firstMessage,
-    last_message: lastMessage,
-    agents_used: Array.from(agentsUsed),
-    has_todos: todos.length > 0,
-    has_transcript: transcriptEntries > 0,
-    todos,
-    transcript_entries: transcriptEntries,
-  }
-}

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

@@ -1,3 +0,0 @@
-export { createSessionManagerTools } from "./tools"
-export * from "./types"
-export * from "./constants"