opencode-repos 0.3.0 → 0.3.2

package/oh-my-opencode/src/features/context-injector/collector.ts

@@ -1,85 +0,0 @@
-import type {
-  ContextEntry,
-  ContextPriority,
-  PendingContext,
-  RegisterContextOptions,
-} from "./types"
-
-const PRIORITY_ORDER: Record<ContextPriority, number> = {
-  critical: 0,
-  high: 1,
-  normal: 2,
-  low: 3,
-}
-
-const CONTEXT_SEPARATOR = "\n\n---\n\n"
-
-export class ContextCollector {
-  private sessions: Map<string, Map<string, ContextEntry>> = new Map()
-
-  register(sessionID: string, options: RegisterContextOptions): void {
-    if (!this.sessions.has(sessionID)) {
-      this.sessions.set(sessionID, new Map())
-    }
-
-    const sessionMap = this.sessions.get(sessionID)!
-    const key = `${options.source}:${options.id}`
-
-    const entry: ContextEntry = {
-      id: options.id,
-      source: options.source,
-      content: options.content,
-      priority: options.priority ?? "normal",
-      timestamp: Date.now(),
-      metadata: options.metadata,
-    }
-
-    sessionMap.set(key, entry)
-  }
-
-  getPending(sessionID: string): PendingContext {
-    const sessionMap = this.sessions.get(sessionID)
-
-    if (!sessionMap || sessionMap.size === 0) {
-      return {
-        merged: "",
-        entries: [],
-        hasContent: false,
-      }
-    }
-
-    const entries = this.sortEntries([...sessionMap.values()])
-    const merged = entries.map((e) => e.content).join(CONTEXT_SEPARATOR)
-
-    return {
-      merged,
-      entries,
-      hasContent: entries.length > 0,
-    }
-  }
-
-  consume(sessionID: string): PendingContext {
-    const pending = this.getPending(sessionID)
-    this.clear(sessionID)
-    return pending
-  }
-
-  clear(sessionID: string): void {
-    this.sessions.delete(sessionID)
-  }
-
-  hasPending(sessionID: string): boolean {
-    const sessionMap = this.sessions.get(sessionID)
-    return sessionMap !== undefined && sessionMap.size > 0
-  }
-
-  private sortEntries(entries: ContextEntry[]): ContextEntry[] {
-    return entries.sort((a, b) => {
-      const priorityDiff = PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]
-      if (priorityDiff !== 0) return priorityDiff
-      return a.timestamp - b.timestamp
-    })
-  }
-}
-
-export const contextCollector = new ContextCollector()

package/oh-my-opencode/src/features/context-injector/index.ts

@@ -1,14 +0,0 @@
-export { ContextCollector, contextCollector } from "./collector"
-export {
-  createContextInjectorMessagesTransformHook,
-} from "./injector"
-export type {
-  ContextSourceType,
-  ContextPriority,
-  ContextEntry,
-  RegisterContextOptions,
-  PendingContext,
-  MessageContext,
-  OutputParts,
-  InjectionStrategy,
-} from "./types"

package/oh-my-opencode/src/features/context-injector/injector.test.ts

@@ -1,122 +0,0 @@
-import { describe, it, expect, beforeEach } from "bun:test"
-import { ContextCollector } from "./collector"
-import {
-  createContextInjectorMessagesTransformHook,
-} from "./injector"
-
-describe("createContextInjectorMessagesTransformHook", () => {
-  let collector: ContextCollector
-
-  beforeEach(() => {
-    collector = new ContextCollector()
-  })
-
-  const createMockMessage = (
-    role: "user" | "assistant",
-    text: string,
-    sessionID: string
-  ) => ({
-    info: {
-      id: `msg_${Date.now()}_${Math.random()}`,
-      sessionID,
-      role,
-      time: { created: Date.now() },
-      agent: "Sisyphus",
-      model: { providerID: "test", modelID: "test" },
-      path: { cwd: "/", root: "/" },
-    },
-    parts: [
-      {
-        id: `part_${Date.now()}`,
-        sessionID,
-        messageID: `msg_${Date.now()}`,
-        type: "text" as const,
-        text,
-      },
-    ],
-  })
-
-  it("inserts synthetic part before text part in last user message", async () => {
-    // #given
-    const hook = createContextInjectorMessagesTransformHook(collector)
-    const sessionID = "ses_transform1"
-    collector.register(sessionID, {
-      id: "ulw",
-      source: "keyword-detector",
-      content: "Ultrawork context",
-    })
-    const messages = [
-      createMockMessage("user", "First message", sessionID),
-      createMockMessage("assistant", "Response", sessionID),
-      createMockMessage("user", "Second message", sessionID),
-    ]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const output = { messages } as any
-
-    // #when
-    await hook["experimental.chat.messages.transform"]!({}, output)
-
-    // #then - synthetic part inserted before original text part
-    expect(output.messages.length).toBe(3)
-    expect(output.messages[2].parts.length).toBe(2)
-    expect(output.messages[2].parts[0].text).toBe("Ultrawork context")
-    expect(output.messages[2].parts[0].synthetic).toBe(true)
-    expect(output.messages[2].parts[1].text).toBe("Second message")
-  })
-
-  it("does nothing when no pending context", async () => {
-    // #given
-    const hook = createContextInjectorMessagesTransformHook(collector)
-    const sessionID = "ses_transform2"
-    const messages = [createMockMessage("user", "Hello world", sessionID)]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const output = { messages } as any
-
-    // #when
-    await hook["experimental.chat.messages.transform"]!({}, output)
-
-    // #then
-    expect(output.messages.length).toBe(1)
-  })
-
-  it("does nothing when no user messages", async () => {
-    // #given
-    const hook = createContextInjectorMessagesTransformHook(collector)
-    const sessionID = "ses_transform3"
-    collector.register(sessionID, {
-      id: "ctx",
-      source: "keyword-detector",
-      content: "Context",
-    })
-    const messages = [createMockMessage("assistant", "Response", sessionID)]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const output = { messages } as any
-
-    // #when
-    await hook["experimental.chat.messages.transform"]!({}, output)
-
-    // #then
-    expect(output.messages.length).toBe(1)
-    expect(collector.hasPending(sessionID)).toBe(true)
-  })
-
-  it("consumes context after injection", async () => {
-    // #given
-    const hook = createContextInjectorMessagesTransformHook(collector)
-    const sessionID = "ses_transform4"
-    collector.register(sessionID, {
-      id: "ctx",
-      source: "keyword-detector",
-      content: "Context",
-    })
-    const messages = [createMockMessage("user", "Message", sessionID)]
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const output = { messages } as any
-
-    // #when
-    await hook["experimental.chat.messages.transform"]!({}, output)
-
-    // #then
-    expect(collector.hasPending(sessionID)).toBe(false)
-  })
-})

package/oh-my-opencode/src/features/context-injector/injector.ts

@@ -1,167 +0,0 @@
-import type { ContextCollector } from "./collector"
-import type { Message, Part } from "@opencode-ai/sdk"
-import { log } from "../../shared"
-import { getMainSessionID } from "../claude-code-session-state"
-
-interface OutputPart {
-  type: string
-  text?: string
-  [key: string]: unknown
-}
-
-interface InjectionResult {
-  injected: boolean
-  contextLength: number
-}
-
-export function injectPendingContext(
-  collector: ContextCollector,
-  sessionID: string,
-  parts: OutputPart[]
-): InjectionResult {
-  if (!collector.hasPending(sessionID)) {
-    return { injected: false, contextLength: 0 }
-  }
-
-  const textPartIndex = parts.findIndex((p) => p.type === "text" && p.text !== undefined)
-  if (textPartIndex === -1) {
-    return { injected: false, contextLength: 0 }
-  }
-
-  const pending = collector.consume(sessionID)
-  const originalText = parts[textPartIndex].text ?? ""
-  parts[textPartIndex].text = `${pending.merged}\n\n---\n\n${originalText}`
-
-  return {
-    injected: true,
-    contextLength: pending.merged.length,
-  }
-}
-
-interface ChatMessageInput {
-  sessionID: string
-  agent?: string
-  model?: { providerID: string; modelID: string }
-  messageID?: string
-}
-
-interface ChatMessageOutput {
-  message: Record<string, unknown>
-  parts: OutputPart[]
-}
-
-export function createContextInjectorHook(collector: ContextCollector) {
-  return {
-    "chat.message": async (
-      input: ChatMessageInput,
-      output: ChatMessageOutput
-    ): Promise<void> => {
-      const result = injectPendingContext(collector, input.sessionID, output.parts)
-      if (result.injected) {
-        log("[context-injector] Injected pending context via chat.message", {
-          sessionID: input.sessionID,
-          contextLength: result.contextLength,
-        })
-      }
-    },
-  }
-}
-
-interface MessageWithParts {
-  info: Message
-  parts: Part[]
-}
-
-type MessagesTransformHook = {
-  "experimental.chat.messages.transform"?: (
-    input: Record<string, never>,
-    output: { messages: MessageWithParts[] }
-  ) => Promise<void>
-}
-
-export function createContextInjectorMessagesTransformHook(
-  collector: ContextCollector
-): MessagesTransformHook {
-  return {
-    "experimental.chat.messages.transform": async (_input, output) => {
-      const { messages } = output
-      log("[DEBUG] experimental.chat.messages.transform called", {
-        messageCount: messages.length,
-      })
-      if (messages.length === 0) {
-        return
-      }
-
-      let lastUserMessageIndex = -1
-      for (let i = messages.length - 1; i >= 0; i--) {
-        if (messages[i].info.role === "user") {
-          lastUserMessageIndex = i
-          break
-        }
-      }
-
-      if (lastUserMessageIndex === -1) {
-        log("[DEBUG] No user message found in messages")
-        return
-      }
-
-      const lastUserMessage = messages[lastUserMessageIndex]
-      // Try message.info.sessionID first, fallback to mainSessionID
-      const messageSessionID = (lastUserMessage.info as unknown as { sessionID?: string }).sessionID
-      const sessionID = messageSessionID ?? getMainSessionID()
-      log("[DEBUG] Extracted sessionID", {
-        messageSessionID,
-        mainSessionID: getMainSessionID(),
-        sessionID,
-        infoKeys: Object.keys(lastUserMessage.info),
-      })
-      if (!sessionID) {
-        log("[DEBUG] sessionID is undefined (both message.info and mainSessionID are empty)")
-        return
-      }
-
-      const hasPending = collector.hasPending(sessionID)
-      log("[DEBUG] Checking hasPending", {
-        sessionID,
-        hasPending,
-      })
-      if (!hasPending) {
-        return
-      }
-
-      const pending = collector.consume(sessionID)
-      if (!pending.hasContent) {
-        return
-      }
-
-      const textPartIndex = lastUserMessage.parts.findIndex(
-        (p) => p.type === "text" && (p as { text?: string }).text
-      )
-
-      if (textPartIndex === -1) {
-        log("[context-injector] No text part found in last user message, skipping injection", {
-          sessionID,
-          partsCount: lastUserMessage.parts.length,
-        })
-        return
-      }
-
-      // synthetic part 패턴 (minimal fields)
-      const syntheticPart = {
-        id: `synthetic_hook_${Date.now()}`,
-        messageID: lastUserMessage.info.id,
-        sessionID: (lastUserMessage.info as { sessionID?: string }).sessionID ?? "",
-        type: "text" as const,
-        text: pending.merged,
-        synthetic: true,  // UI에서 숨겨짐
-      }
-
-      lastUserMessage.parts.splice(textPartIndex, 0, syntheticPart as Part)
-
-      log("[context-injector] Inserted synthetic part with hook content", {
-        sessionID,
-        contentLength: pending.merged.length,
-      })
-    },
-  }
-}

package/oh-my-opencode/src/features/context-injector/types.ts

@@ -1,91 +0,0 @@
-/**
- * Source identifier for context injection
- * Each source registers context that will be merged and injected together
- */
-export type ContextSourceType =
-  | "keyword-detector"
-  | "rules-injector"
-  | "directory-agents"
-  | "directory-readme"
-  | "custom"
-
-/**
- * Priority levels for context ordering
- * Higher priority contexts appear first in the merged output
- */
-export type ContextPriority = "critical" | "high" | "normal" | "low"
-
-/**
- * A single context entry registered by a source
- */
-export interface ContextEntry {
-  /** Unique identifier for this entry within the source */
-  id: string
-  /** The source that registered this context */
-  source: ContextSourceType
-  /** The actual context content to inject */
-  content: string
-  /** Priority for ordering (default: normal) */
-  priority: ContextPriority
-  /** Timestamp when registered */
-  timestamp: number
-  /** Optional metadata for debugging/logging */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Options for registering context
- */
-export interface RegisterContextOptions {
-  /** Unique ID for this context entry (used for deduplication) */
-  id: string
-  /** Source identifier */
-  source: ContextSourceType
-  /** The content to inject */
-  content: string
-  /** Priority for ordering (default: normal) */
-  priority?: ContextPriority
-  /** Optional metadata */
-  metadata?: Record<string, unknown>
-}
-
-/**
- * Result of getting pending context for a session
- */
-export interface PendingContext {
-  /** Merged context string, ready for injection */
-  merged: string
-  /** Individual entries that were merged */
-  entries: ContextEntry[]
-  /** Whether there's any content to inject */
-  hasContent: boolean
-}
-
-/**
- * Message context from the original user message
- * Used when injecting to match the message format
- */
-export interface MessageContext {
-  agent?: string
-  model?: {
-    providerID?: string
-    modelID?: string
-  }
-  path?: {
-    cwd?: string
-    root?: string
-  }
-  tools?: Record<string, boolean>
-}
-
-/**
- * Output parts from chat.message hook
- */
-export interface OutputParts {
-  parts: Array<{ type: string; text?: string; [key: string]: unknown }>
-}
-
-/**
- * Injection strategy
- */
-export type InjectionStrategy = "prepend-parts" | "storage" | "auto"

package/oh-my-opencode/src/features/hook-message-injector/constants.ts

@@ -1,6 +0,0 @@
-import { join } from "node:path"
-import { getOpenCodeStorageDir } from "../../shared/data-path"
-
-export const OPENCODE_STORAGE = getOpenCodeStorageDir()
-export const MESSAGE_STORAGE = join(OPENCODE_STORAGE, "message")
-export const PART_STORAGE = join(OPENCODE_STORAGE, "part")

package/oh-my-opencode/src/features/hook-message-injector/index.ts

@@ -1,4 +0,0 @@
-export { injectHookMessage, findNearestMessageWithFields, findFirstMessageWithAgent } from "./injector"
-export type { StoredMessage } from "./injector"
-export type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types"
-export { MESSAGE_STORAGE } from "./constants"

package/oh-my-opencode/src/features/hook-message-injector/injector.ts

@@ -1,195 +0,0 @@
-import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs"
-import { join } from "node:path"
-import { MESSAGE_STORAGE, PART_STORAGE } from "./constants"
-import type { MessageMeta, OriginalMessageContext, TextPart, ToolPermission } from "./types"
-
-export interface StoredMessage {
-  agent?: string
-  model?: { providerID?: string; modelID?: string }
-  tools?: Record<string, ToolPermission>
-}
-
-export function findNearestMessageWithFields(messageDir: string): StoredMessage | null {
-  try {
-    const files = readdirSync(messageDir)
-      .filter((f) => f.endsWith(".json"))
-      .sort()
-      .reverse()
-
-    // First pass: find message with ALL fields (ideal)
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(messageDir, file), "utf-8")
-        const msg = JSON.parse(content) as StoredMessage
-        if (msg.agent && msg.model?.providerID && msg.model?.modelID) {
-          return msg
-        }
-      } catch {
-        continue
-      }
-    }
-
-    // Second pass: find message with ANY useful field (fallback)
-    // This ensures agent info isn't lost when model info is missing
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(messageDir, file), "utf-8")
-        const msg = JSON.parse(content) as StoredMessage
-        if (msg.agent || (msg.model?.providerID && msg.model?.modelID)) {
-          return msg
-        }
-      } catch {
-        continue
-      }
-    }
-  } catch {
-    return null
-  }
-  return null
-}
-
-/**
- * Finds the FIRST (oldest) message in the session with agent field.
- * This is used to get the original agent that started the session,
- * avoiding issues where newer messages may have a different agent
- * due to OpenCode's internal agent switching.
- */
-export function findFirstMessageWithAgent(messageDir: string): string | null {
-  try {
-    const files = readdirSync(messageDir)
-      .filter((f) => f.endsWith(".json"))
-      .sort() // Oldest first (no reverse)
-
-    for (const file of files) {
-      try {
-        const content = readFileSync(join(messageDir, file), "utf-8")
-        const msg = JSON.parse(content) as StoredMessage
-        if (msg.agent) {
-          return msg.agent
-        }
-      } catch {
-        continue
-      }
-    }
-  } catch {
-    return null
-  }
-  return null
-}
-
-function generateMessageId(): string {
-  const timestamp = Date.now().toString(16)
-  const random = Math.random().toString(36).substring(2, 14)
-  return `msg_${timestamp}${random}`
-}
-
-function generatePartId(): string {
-  const timestamp = Date.now().toString(16)
-  const random = Math.random().toString(36).substring(2, 10)
-  return `prt_${timestamp}${random}`
-}
-
-function getOrCreateMessageDir(sessionID: string): string {
-  if (!existsSync(MESSAGE_STORAGE)) {
-    mkdirSync(MESSAGE_STORAGE, { recursive: true })
-  }
-
-  const directPath = join(MESSAGE_STORAGE, sessionID)
-  if (existsSync(directPath)) {
-    return directPath
-  }
-
-  for (const dir of readdirSync(MESSAGE_STORAGE)) {
-    const sessionPath = join(MESSAGE_STORAGE, dir, sessionID)
-    if (existsSync(sessionPath)) {
-      return sessionPath
-    }
-  }
-
-  mkdirSync(directPath, { recursive: true })
-  return directPath
-}
-
-export function injectHookMessage(
-  sessionID: string,
-  hookContent: string,
-  originalMessage: OriginalMessageContext
-): boolean {
-  // Validate hook content to prevent empty message injection
-  if (!hookContent || hookContent.trim().length === 0) {
-    console.warn("[hook-message-injector] Attempted to inject empty hook content, skipping injection", {
-      sessionID,
-      hasAgent: !!originalMessage.agent,
-      hasModel: !!(originalMessage.model?.providerID && originalMessage.model?.modelID)
-    })
-    return false
-  }
-
-  const messageDir = getOrCreateMessageDir(sessionID)
-
-  const needsFallback =
-    !originalMessage.agent ||
-    !originalMessage.model?.providerID ||
-    !originalMessage.model?.modelID
-
-  const fallback = needsFallback ? findNearestMessageWithFields(messageDir) : null
-
-  const now = Date.now()
-  const messageID = generateMessageId()
-  const partID = generatePartId()
-
-  const resolvedAgent = originalMessage.agent ?? fallback?.agent ?? "general"
-  const resolvedModel =
-    originalMessage.model?.providerID && originalMessage.model?.modelID
-      ? { providerID: originalMessage.model.providerID, modelID: originalMessage.model.modelID }
-      : fallback?.model?.providerID && fallback?.model?.modelID
-        ? { providerID: fallback.model.providerID, modelID: fallback.model.modelID }
-        : undefined
-  const resolvedTools = originalMessage.tools ?? fallback?.tools
-
-  const messageMeta: MessageMeta = {
-    id: messageID,
-    sessionID,
-    role: "user",
-    time: {
-      created: now,
-    },
-    agent: resolvedAgent,
-    model: resolvedModel,
-    path:
-      originalMessage.path?.cwd
-        ? {
-            cwd: originalMessage.path.cwd,
-            root: originalMessage.path.root ?? "/",
-          }
-        : undefined,
-    tools: resolvedTools,
-  }
-
-  const textPart: TextPart = {
-    id: partID,
-    type: "text",
-    text: hookContent,
-    synthetic: true,
-    time: {
-      start: now,
-      end: now,
-    },
-    messageID,
-    sessionID,
-  }
-
-  try {
-    writeFileSync(join(messageDir, `${messageID}.json`), JSON.stringify(messageMeta, null, 2))
-
-    const partDir = join(PART_STORAGE, messageID)
-    if (!existsSync(partDir)) {
-      mkdirSync(partDir, { recursive: true })
-    }
-    writeFileSync(join(partDir, `${partID}.json`), JSON.stringify(textPart, null, 2))
-
-    return true
-  } catch {
-    return false
-  }
-}