sapient/oh-my-openagent
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor: remove 3 orphaned files and prefix unused parameter

Browse Source
This commit is contained in:
YeonGyu-Kim
2026-02-17 14:09:12 +09:00
parent 9acdd6b85d
commit 462e2ec2b0
4 changed files with 1 additions and 211 deletions
Download Patch File Download Diff File Expand all files Collapse all files

81
src/hooks/interactive-bash-session/interactive-bash-session-hook.ts
View File

@@ -1,81 +0,0 @@
import type { PluginInput } from "@opencode-ai/plugin";
import { createInteractiveBashSessionTracker } from "./interactive-bash-session-tracker";
import { parseTmuxCommand } from "./tmux-command-parser";
interface ToolExecuteInput {
tool: string;
sessionID: string;
callID: string;
args?: Record<string, unknown>;
}
interface ToolExecuteOutput {
title: string;
output: string;
metadata: unknown;
}
interface EventInput {
event: {
type: string;
properties?: unknown;
};
}
export function createInteractiveBashSessionHook(ctx: PluginInput) {
const tracker = createInteractiveBashSessionTracker({
abortSession: (args) => ctx.client.session.abort(args),
})
const toolExecuteAfter = async (
input: ToolExecuteInput,
output: ToolExecuteOutput,
) => {
const { tool, sessionID, args } = input;
const toolLower = tool.toLowerCase();
if (toolLower !== "interactive_bash") {
return;
}
if (typeof args?.tmux_command !== "string") {
return;
}
const tmuxCommand = args.tmux_command;
const { subCommand, sessionName } = parseTmuxCommand(tmuxCommand)
const toolOutput = output?.output ?? ""
if (toolOutput.startsWith("Error:")) {
return
}
const { reminderToAppend } = tracker.handleTmuxCommand({
sessionID,
subCommand,
sessionName,
toolOutput,
})
if (reminderToAppend) {
output.output += reminderToAppend
}
};
const eventHandler = async ({ event }: EventInput) => {
const props = event.properties as Record<string, unknown> | undefined;
if (event.type === "session.deleted") {
const sessionInfo = props?.info as { id?: string } | undefined;
const sessionID = sessionInfo?.id;
if (sessionID) {
await tracker.handleSessionDeleted(sessionID)
}
}
};
return {
"tool.execute.after": toolExecuteAfter,
event: eventHandler,
};
}

115
src/shared/available-models-fetcher.ts
View File

@@ -1,115 +0,0 @@
import { addModelsFromModelsJsonCache } from "./models-json-cache-reader"
import { getModelListFunction, getProviderListFunction } from "./open-code-client-accessors"
import { addModelsFromProviderModelsCache } from "./provider-models-cache-model-reader"
import { log } from "./logger"
import { normalizeSDKResponse } from "./normalize-sdk-response"
export async function getConnectedProviders(client: unknown): Promise<string[]> {
const providerList = getProviderListFunction(client)
if (!providerList) {
log("[getConnectedProviders] client.provider.list not available")
return []
}
try {
const result = await providerList()
const connected = result.data?.connected ?? []
log("[getConnectedProviders] connected providers", {
count: connected.length,
providers: connected,
})
return connected
} catch (err) {
log("[getConnectedProviders] SDK error", { error: String(err) })
return []
}
}
export async function fetchAvailableModels(
client?: unknown,
options?: { connectedProviders?: string[] | null },
): Promise<Set<string>> {
let connectedProviders = options?.connectedProviders ?? null
let connectedProvidersUnknown = connectedProviders === null
log("[fetchAvailableModels] CALLED", {
connectedProvidersUnknown,
connectedProviders: options?.connectedProviders,
})
if (connectedProvidersUnknown && client !== undefined) {
const liveConnected = await getConnectedProviders(client)
if (liveConnected.length > 0) {
connectedProviders = liveConnected
connectedProvidersUnknown = false
log("[fetchAvailableModels] connected providers fetched from client", {
count: liveConnected.length,
})
}
}
if (connectedProvidersUnknown) {
const modelList = client === undefined ? null : getModelListFunction(client)
if (modelList) {
const modelSet = new Set<string>()
try {
const modelsResult = await modelList()
const models = normalizeSDKResponse(modelsResult, [] as Array<{ provider?: string; id?: string }>)
for (const model of models) {
if (model.provider && model.id) {
modelSet.add(`${model.provider}/${model.id}`)
}
}
log(
"[fetchAvailableModels] fetched models from client without provider filter",
{ count: modelSet.size },
)
return modelSet
} catch (err) {
log("[fetchAvailableModels] client.model.list error", {
error: String(err),
})
}
}
log(
"[fetchAvailableModels] connected providers unknown, returning empty set for fallback resolution",
)
return new Set<string>()
}
const connectedProvidersList = connectedProviders ?? []
const connectedSet = new Set(connectedProvidersList)
const modelSet = new Set<string>()
if (addModelsFromProviderModelsCache(connectedSet, modelSet)) {
return modelSet
}
log("[fetchAvailableModels] provider-models cache not found, falling back to models.json")
if (addModelsFromModelsJsonCache(connectedSet, modelSet)) {
return modelSet
}
const modelList = client === undefined ? null : getModelListFunction(client)
if (modelList) {
try {
const modelsResult = await modelList()
const models = normalizeSDKResponse(modelsResult, [] as Array<{ provider?: string; id?: string }>)
for (const model of models) {
if (!model.provider || !model.id) continue
if (connectedSet.has(model.provider)) {
modelSet.add(`${model.provider}/${model.id}`)
}
}
log("[fetchAvailableModels] fetched models from client (filtered)", {
count: modelSet.size,
connectedProviders: connectedProvidersList.slice(0, 5),
})
} catch (err) {
log("[fetchAvailableModels] client.model.list error", { error: String(err) })
}
}
return modelSet
}

14
src/shared/model-cache-availability.ts
View File

@@ -1,14 +0,0 @@
import { existsSync } from "fs"
import { join } from "path"
import { getOpenCodeCacheDir } from "./data-path"
import { hasProviderModelsCache } from "./connected-providers-cache"
export function __resetModelCache(): void {}
export function isModelCacheAvailable(): boolean {
if (hasProviderModelsCache()) {
return true
}
const cacheFile = join(getOpenCodeCacheDir(), "models.json")
return existsSync(cacheFile)
}

2
src/tools/hashline-edit/hash-computation.ts
View File

@@ -1,6 +1,6 @@
import { HASH_DICT } from "./constants"
export function computeLineHash(lineNumber: number, content: string): string {
export function computeLineHash(_lineNumber: number, content: string): string {
const stripped = content.replace(/\s+/g, "")
const hash = Bun.hash.xxHash32(stripped)
const index = hash % 256