@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/shared/data-path.ts

@@ -1,64 +0,0 @@
-import * as path from "node:path"
-import * as os from "node:os"
-import { accessSync, constants, mkdirSync } from "node:fs"
-
-import { CACHE_DIR_NAME } from "./plugin-identity"
-
-function resolveWritableDirectory(preferredDir: string, fallbackSuffix: string): string {
-  try {
-    mkdirSync(preferredDir, { recursive: true })
-    accessSync(preferredDir, constants.W_OK)
-    return preferredDir
-  } catch {
-    const fallbackDir = path.join(os.tmpdir(), fallbackSuffix)
-    mkdirSync(fallbackDir, { recursive: true })
-    return fallbackDir
-  }
-}
-
-/**
- * Returns the user-level data directory.
- * Matches OpenCode's behavior via xdg-basedir:
- * - All platforms: XDG_DATA_HOME or ~/.local/share
- *
- * Note: OpenCode uses xdg-basedir which returns ~/.local/share on ALL platforms
- * including Windows, so we match that behavior exactly.
- */
-export function getDataDir(): string {
-  const preferredDir = process.env.XDG_DATA_HOME ?? path.join(os.homedir(), ".local", "share")
-  return resolveWritableDirectory(preferredDir, "opencode-data")
-}
-
-/**
- * Returns the OpenCode storage directory path.
- * All platforms: ~/.local/share/opencode/storage
- */
-export function getOpenCodeStorageDir(): string {
-  return path.join(getDataDir(), "opencode", "storage")
-}
-
-/**
- * Returns the user-level cache directory.
- * Matches OpenCode's behavior via xdg-basedir:
- * - All platforms: XDG_CACHE_HOME or ~/.cache
- */
-export function getCacheDir(): string {
-  const preferredDir = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), ".cache")
-  return resolveWritableDirectory(preferredDir, "opencode-cache")
-}
-
-/**
- * Returns the hiai-opencode cache directory.
- * All platforms: ~/.cache/hiai-opencode
- */
-export function getOmoOpenCodeCacheDir(): string {
-  return path.join(getCacheDir(), CACHE_DIR_NAME)
-}
-
-/**
- * Returns the OpenCode cache directory (for reading OpenCode's cache).
- * All platforms: ~/.cache/opencode
- */
-export function getOpenCodeCacheDir(): string {
-  return path.join(getCacheDir(), "opencode")
-}

package/src/shared/deep-merge.ts

@@ -1,53 +0,0 @@
-const DANGEROUS_KEYS = new Set(["__proto__", "constructor", "prototype"]);
-const MAX_DEPTH = 50;
-
-export function isPlainObject(value: unknown): value is Record<string, unknown> {
-  return (
-    typeof value === "object" &&
-    value !== null &&
-    !Array.isArray(value) &&
-    Object.prototype.toString.call(value) === "[object Object]"
-  );
-}
-
-/**
- * Deep merges two objects, with override values taking precedence.
- * - Objects are recursively merged
- * - Arrays are replaced (not concatenated)
- * - undefined values in override do not overwrite base values
- *
- * @example
- * deepMerge({ a: 1, b: { c: 2, d: 3 } }, { b: { c: 10 }, e: 5 })
- * // => { a: 1, b: { c: 10, d: 3 }, e: 5 }
- */
-export function deepMerge<T extends Record<string, unknown>>(base: T, override: Partial<T>, depth?: number): T;
-export function deepMerge<T extends Record<string, unknown>>(base: T | undefined, override: T | undefined, depth?: number): T | undefined;
-export function deepMerge<T extends Record<string, unknown>>(
-  base: T | undefined,
-  override: T | undefined,
-  depth = 0
-): T | undefined {
-  if (!base && !override) return undefined;
-  if (!base) return override;
-  if (!override) return base;
-  if (depth > MAX_DEPTH) return override ?? base;
-
-  const result = { ...base } as Record<string, unknown>;
-
-  for (const key of Object.keys(override)) {
-    if (DANGEROUS_KEYS.has(key)) continue;
-
-    const baseValue = base[key];
-    const overrideValue = override[key];
-
-    if (overrideValue === undefined) continue;
-
-    if (isPlainObject(baseValue) && isPlainObject(overrideValue)) {
-      result[key] = deepMerge(baseValue, overrideValue, depth + 1);
-    } else {
-      result[key] = overrideValue;
-    }
-  }
-
-  return result as T;
-}

package/src/shared/disabled-tools.ts

@@ -1,19 +0,0 @@
-import type { ToolDefinition } from "@opencode-ai/plugin"
-
-export function filterDisabledTools(
-  tools: Record<string, ToolDefinition>,
-  disabledTools: readonly string[] | undefined
-): Record<string, ToolDefinition> {
-  if (!disabledTools || disabledTools.length === 0) {
-    return tools
-  }
-
-  const disabledToolSet = new Set(disabledTools)
-  const filtered: Record<string, ToolDefinition> = {}
-  for (const [toolName, toolDefinition] of Object.entries(tools)) {
-    if (!disabledToolSet.has(toolName)) {
-      filtered[toolName] = toolDefinition
-    }
-  }
-  return filtered
-}

package/src/shared/dynamic-truncator.ts

@@ -1,222 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import {
-	resolveActualContextLimit,
-	type ContextLimitModelCacheState,
-} from "./context-limit-resolver"
-import { normalizeSDKResponse } from "./normalize-sdk-response"
-
-const CHARS_PER_TOKEN_ESTIMATE = 4;
-const DEFAULT_TARGET_MAX_TOKENS = 50_000;
-
-interface AssistantMessageInfo {
-	role: "assistant";
-	providerID?: string;
-	modelID?: string;
-	tokens: {
-		input: number;
-		output: number;
-		reasoning: number;
-		cache: { read: number; write: number };
-	};
-}
-
-interface MessageWrapper {
-	info: { role: string } & Partial<AssistantMessageInfo>;
-}
-
-export interface TruncationResult {
-	result: string;
-	truncated: boolean;
-	removedCount?: number;
-}
-
-export interface TruncationOptions {
-	targetMaxTokens?: number;
-	preserveHeaderLines?: number;
-	contextWindowLimit?: number;
-}
-
-function estimateTokens(text: string): number {
-	return Math.ceil(text.length / CHARS_PER_TOKEN_ESTIMATE);
-}
-
-export function truncateToTokenLimit(
-	output: string,
-	maxTokens: number,
-	preserveHeaderLines = 3,
-): TruncationResult {
-	if (typeof output !== 'string') {
-		return { result: String(output ?? ''), truncated: false };
-	}
-
-	const currentTokens = estimateTokens(output);
-
-	if (currentTokens <= maxTokens) {
-		return { result: output, truncated: false };
-	}
-
-	const lines = output.split("\n");
-
-	if (lines.length <= preserveHeaderLines) {
-		const maxChars = maxTokens * CHARS_PER_TOKEN_ESTIMATE;
-		return {
-			result:
-				output.slice(0, maxChars) +
-				"\n\n[Output truncated due to context window limit]",
-			truncated: true,
-		};
-	}
-
-	const headerLines = lines.slice(0, preserveHeaderLines);
-	const contentLines = lines.slice(preserveHeaderLines);
-
-	const headerText = headerLines.join("\n");
-	const headerTokens = estimateTokens(headerText);
-	const truncationMessageTokens = 50;
-	const availableTokens = maxTokens - headerTokens - truncationMessageTokens;
-
-	if (availableTokens <= 0) {
-		return {
-			result:
-				headerText + "\n\n[Content truncated due to context window limit]",
-			truncated: true,
-			removedCount: contentLines.length,
-		};
-	}
-
-	const resultLines: string[] = [];
-	let currentTokenCount = 0;
-
-	for (const line of contentLines) {
-		const lineTokens = estimateTokens(line + "\n");
-		if (currentTokenCount + lineTokens > availableTokens) {
-			break;
-		}
-		resultLines.push(line);
-		currentTokenCount += lineTokens;
-	}
-
-	const truncatedContent = [...headerLines, ...resultLines].join("\n");
-	const removedCount = contentLines.length - resultLines.length;
-
-	return {
-		result:
-			truncatedContent +
-			`\n\n[${removedCount} more lines truncated due to context window limit]`,
-		truncated: true,
-		removedCount,
-	};
-}
-
-export async function getContextWindowUsage(
-	ctx: PluginInput,
-	sessionID: string,
-	modelCacheState?: ContextLimitModelCacheState,
-): Promise<{
-	usedTokens: number;
-	remainingTokens: number;
-	usagePercentage: number;
-} | null> {
-	try {
-		const response = await ctx.client.session.messages({
-			path: { id: sessionID },
-		});
-
-		const messages = normalizeSDKResponse(response, [] as MessageWrapper[], { preferResponseOnMissingData: true })
-
-		const assistantMessages = messages
-			.filter((m) => m.info.role === "assistant")
-			.map((m) => m.info as AssistantMessageInfo);
-
-		if (assistantMessages.length === 0) return null;
-		
-		const lastAssistant = assistantMessages[assistantMessages.length - 1];
-		const lastTokens = lastAssistant?.tokens;
-		if (!lastAssistant || !lastTokens) return null;
-
-		const actualLimit =
-			lastAssistant.providerID !== undefined
-				? resolveActualContextLimit(
-					lastAssistant.providerID,
-					lastAssistant.modelID ?? "",
-					modelCacheState,
-				)
-				: null;
-
-		if (!actualLimit) return null;
-
-		const usedTokens =
-			(lastTokens?.input ?? 0) +
-			(lastTokens?.cache?.read ?? 0) +
-			(lastTokens?.output ?? 0);
-		const remainingTokens = actualLimit - usedTokens;
-
-		return {
-			usedTokens,
-			remainingTokens,
-			usagePercentage: usedTokens / actualLimit,
-		};
-	} catch {
-		return null;
-	}
-}
-
-export async function dynamicTruncate(
-	ctx: PluginInput,
-	sessionID: string,
-	output: string,
-	options: TruncationOptions = {},
-	modelCacheState?: ContextLimitModelCacheState,
-): Promise<TruncationResult> {
-	if (typeof output !== 'string') {
-		return { result: String(output ?? ''), truncated: false };
-	}
-
-	const {
-		targetMaxTokens = DEFAULT_TARGET_MAX_TOKENS,
-		preserveHeaderLines = 3,
-	} = options;
-
-	const usage = await getContextWindowUsage(ctx, sessionID, modelCacheState);
-
-	if (!usage) {
-		// Fallback: apply conservative truncation when context usage unavailable
-		return truncateToTokenLimit(output, targetMaxTokens, preserveHeaderLines);
-	}
-
-	const maxOutputTokens = Math.min(
-		usage.remainingTokens * 0.5,
-		targetMaxTokens,
-	);
-
-	if (maxOutputTokens <= 0) {
-		return {
-			result: "[Output suppressed - context window exhausted]",
-			truncated: true,
-		};
-	}
-
-	return truncateToTokenLimit(output, maxOutputTokens, preserveHeaderLines);
-}
-
-export function createDynamicTruncator(
-	ctx: PluginInput,
-	modelCacheState?: ContextLimitModelCacheState,
-) {
-	return {
-		truncate: (
-			sessionID: string,
-			output: string,
-			options?: TruncationOptions,
-		) => dynamicTruncate(ctx, sessionID, output, options, modelCacheState),
-
-		getUsage: (sessionID: string) =>
-			getContextWindowUsage(ctx, sessionID, modelCacheState),
-
-		truncateSync: (
-			output: string,
-			maxTokens: number,
-			preserveHeaderLines?: number,
-		) => truncateToTokenLimit(output, maxTokens, preserveHeaderLines),
-	};
-}

package/src/shared/external-plugin-detector.ts

@@ -1,139 +0,0 @@
-/**
- * Detects external plugins that may conflict with hiai-opencode features.
- * Used to prevent crashes from concurrent notification plugins.
- */
-
-import { loadOpencodePlugins } from "./load-opencode-plugins"
-import { log } from "./logger"
-import { CONFIG_BASENAME, PLUGIN_NAME } from "./plugin-identity"
-
-/**
- * Known notification plugins that conflict with hiai-opencode's session-notification.
- * Both plugins listen to session.idle and send notifications simultaneously,
- * which can cause crashes on Windows due to resource contention.
- */
-const KNOWN_NOTIFICATION_PLUGINS = [
-  "opencode-notifier",
-  "@mohak34/opencode-notifier",
-  "mohak34/opencode-notifier",
-]
-
-/**
- * Known skill plugins that conflict with hiai-opencode's skill loading.
- * Both plugins scan ~/.config/opencode/skills/ and register tools independently,
- * causing "Duplicate tool names detected" warnings and HTTP 400 errors.
- */
-const KNOWN_SKILL_PLUGINS = [
-  "opencode-skills",
-  "@opencode/skills",
-]
-
-function matchesKnownPlugin(entry: string, knownPlugins: readonly string[]): string | null {
-  const normalized = entry.toLowerCase()
-  for (const known of knownPlugins) {
-    if (normalized === known) return known
-    if (normalized.startsWith(`${known}@`)) return known
-    if (normalized === `npm:${known}` || normalized.startsWith(`npm:${known}@`)) return known
-    if (normalized.startsWith("file://") && (
-      normalized.endsWith(`/${known}`) ||
-      normalized.endsWith(`\\${known}`)
-    )) return known
-  }
-
-  return null
-}
-
-export interface ExternalNotifierResult {
-  detected: boolean
-  pluginName: string | null
-  allPlugins: string[]
-}
-
-export interface ExternalSkillPluginResult {
-  detected: boolean
-  pluginName: string | null
-  allPlugins: string[]
-}
-
-/**
- * Detect if any external notification plugin is configured.
- * Returns information about detected plugins for logging/warning.
- */
-export function detectExternalNotificationPlugin(directory: string): ExternalNotifierResult {
-  const plugins = loadOpencodePlugins(directory)
-
-  for (const plugin of plugins) {
-    const match = matchesKnownPlugin(plugin, KNOWN_NOTIFICATION_PLUGINS)
-    if (match) {
-      log(`Detected external notification plugin: ${plugin}`)
-      return {
-        detected: true,
-        pluginName: match,
-        allPlugins: plugins,
-      }
-    }
-  }
-
-  return {
-    detected: false,
-    pluginName: null,
-    allPlugins: plugins,
-  }
-}
-
-/**
- * Detect if any external skill plugin is configured.
- * Returns information about detected plugins for logging/warning.
- */
-export function detectExternalSkillPlugin(directory: string): ExternalSkillPluginResult {
-  const plugins = loadOpencodePlugins(directory)
-
-  for (const plugin of plugins) {
-    const match = matchesKnownPlugin(plugin, KNOWN_SKILL_PLUGINS)
-    if (match) {
-      log(`Detected external skill plugin: ${plugin}`)
-      return {
-        detected: true,
-        pluginName: match,
-        allPlugins: plugins,
-      }
-    }
-  }
-
-  return {
-    detected: false,
-    pluginName: null,
-    allPlugins: plugins,
-  }
-}
-
-/**
- * Generate a warning message for users with conflicting notification plugins.
- */
-export function getNotificationConflictWarning(pluginName: string): string {
-  return `[${PLUGIN_NAME}] External notification plugin detected: ${pluginName}
-
-Both ${PLUGIN_NAME} and ${pluginName} listen to session.idle events.
-   Running both simultaneously can cause crashes on Windows.
-
-   ${PLUGIN_NAME}'s session-notification has been auto-disabled.
-
-   To use ${PLUGIN_NAME}'s notifications instead, either:
-   1. Remove ${pluginName} from your opencode.json plugins
-   2. Or set "notification": { "force_enable": true } in ${CONFIG_BASENAME}.json`
-}
-
-/**
- * Generate a warning message for users with conflicting skill plugins.
- */
-export function getSkillPluginConflictWarning(pluginName: string): string {
-  return `[${PLUGIN_NAME}] External skill plugin detected: ${pluginName}
-
-Both ${PLUGIN_NAME} and ${pluginName} scan ~/.config/opencode/skills/ and register tools independently.
-   Running both simultaneously causes "Duplicate tool names detected" warnings and HTTP 400 errors.
-
-   Consider either:
-   1. Remove ${pluginName} from your opencode.json plugins to use ${PLUGIN_NAME}'s skill loading
-   2. Or disable ${PLUGIN_NAME}'s skill loading by setting "claude_code.skills": false in ${CONFIG_BASENAME}.json
-   3. Or uninstall ${PLUGIN_NAME} if you prefer ${pluginName}'s skill management`
-}

package/src/shared/fallback-chain-from-models.ts

@@ -1,124 +0,0 @@
-import type { FallbackEntry } from "./model-requirements"
-import type { FallbackModelObject } from "../config/schema/fallback-models"
-import { normalizeFallbackModels } from "./model-resolver"
-import { KNOWN_VARIANTS } from "./known-variants"
-
-function parseVariantFromModel(rawModel: string): { modelID: string; variant?: string } {
-  const trimmedModel = rawModel.trim()
-  if (!trimmedModel) {
-    return { modelID: "" }
-  }
-
-  const parenthesizedVariant = trimmedModel.match(/^(.*)\(([^()]+)\)\s*$/)
-  if (parenthesizedVariant) {
-    const modelID = parenthesizedVariant[1]?.trim() ?? ""
-    const variant = parenthesizedVariant[2]?.trim()
-    return variant ? { modelID, variant } : { modelID }
-  }
-
-  const spaceVariant = trimmedModel.match(/^(.*\S)\s+([a-z][a-z0-9_-]*)$/i)
-  if (spaceVariant) {
-    const modelID = spaceVariant[1]?.trim() ?? ""
-    const variant = spaceVariant[2]?.trim().toLowerCase()
-    if (variant && KNOWN_VARIANTS.has(variant)) {
-      return { modelID, variant }
-    }
-  }
-
-  return { modelID: trimmedModel }
-}
-
-export function parseFallbackModelEntry(
-  model: string,
-  contextProviderID: string | undefined,
-  defaultProviderID = "opencode",
-): FallbackEntry | undefined {
-  const trimmed = model.trim()
-  if (!trimmed) return undefined
-
-  const parts = trimmed.split("/")
-  const providerID =
-    parts.length >= 2 ? parts[0].trim() : (contextProviderID?.trim() || defaultProviderID)
-  const rawModelID = parts.length >= 2 ? parts.slice(1).join("/").trim() : trimmed
-  if (!providerID || !rawModelID) return undefined
-
-  const parsed = parseVariantFromModel(rawModelID)
-  if (!parsed.modelID) return undefined
-
-  return {
-    providers: [providerID],
-    model: parsed.modelID,
-    variant: parsed.variant,
-  }
-}
-
-export function parseFallbackModelObjectEntry(
-  obj: FallbackModelObject,
-  contextProviderID: string | undefined,
-  defaultProviderID = "opencode",
-): FallbackEntry | undefined {
-  const base = parseFallbackModelEntry(obj.model, contextProviderID, defaultProviderID)
-  if (!base) return undefined
-
-  return {
-    ...base,
-    variant: obj.variant ?? base.variant,
-    reasoningEffort: obj.reasoningEffort,
-    temperature: obj.temperature,
-    top_p: obj.top_p,
-    maxTokens: obj.maxTokens,
-    thinking: obj.thinking,
-  }
-}
-
-/**
- * Find the most specific FallbackEntry whose `provider/model` is a prefix of
- * the resolved `provider/modelID`.  Longest match wins so that e.g.
- * `openai/gpt-5.4-preview` picks the entry for `openai/gpt-5.4-preview` over
- * the shorter `openai/gpt-5.4`.
- */
-export function findMostSpecificFallbackEntry(
-  providerID: string,
-  modelID: string,
-  chain: FallbackEntry[],
-): FallbackEntry | undefined {
-  const resolved = `${providerID}/${modelID}`.toLowerCase()
-
-  // Collect entries whose provider/model is a prefix of the resolved model,
-  // together with the length of the matching prefix (longest match wins).
-  const matches: { entry: FallbackEntry; matchLen: number }[] = []
-  for (const entry of chain) {
-    for (const p of entry.providers) {
-      const candidate = `${p}/${entry.model}`.toLowerCase()
-      if (resolved.startsWith(candidate)) {
-        matches.push({ entry, matchLen: candidate.length })
-        break // one match per entry is enough
-      }
-    }
-  }
-
-  if (matches.length === 0) return undefined
-  matches.sort((a, b) => b.matchLen - a.matchLen)
-  return matches[0].entry
-}
-
-export function buildFallbackChainFromModels(
-  fallbackModels: string | (string | FallbackModelObject)[] | undefined,
-  contextProviderID: string | undefined,
-  defaultProviderID = "opencode",
-): FallbackEntry[] | undefined {
-  const normalized = normalizeFallbackModels(fallbackModels)
-  if (!normalized || normalized.length === 0) return undefined
-
-  const parsed = normalized
-    .map((entry) => {
-      if (typeof entry === "string") {
-        return parseFallbackModelEntry(entry, contextProviderID, defaultProviderID)
-      }
-      return parseFallbackModelObjectEntry(entry, contextProviderID, defaultProviderID)
-    })
-    .filter((entry): entry is FallbackEntry => entry !== undefined)
-
-  if (parsed.length === 0) return undefined
-  return parsed
-}