@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/tools/slashcommand/command-discovery.ts

@@ -1,161 +0,0 @@
-import { existsSync, readdirSync, readFileSync, statSync } from "fs"
-import { basename, join } from "path"
-import {
-  parseFrontmatter,
-  sanitizeModelField,
-  findProjectOpencodeCommandDirs,
-  getOpenCodeCommandDirs,
-  discoverPluginCommandDefinitions,
-} from "../../shared"
-import type { CommandFrontmatter } from "../../features/claude-code-command-loader/types"
-import { isMarkdownFile } from "../../shared/file-utils"
-import { getClaudeConfigDir, log } from "../../shared"
-import { loadBuiltinCommands } from "../../features/builtin-commands"
-import type { CommandInfo, CommandMetadata, CommandScope } from "./types"
-
-export interface CommandDiscoveryOptions {
-  pluginsEnabled?: boolean
-  enabledPluginsOverride?: Record<string, boolean>
-}
-
-const NESTED_COMMAND_SEPARATOR = "/"
-
-function discoverCommandsFromDir(
-  commandsDir: string,
-  scope: CommandScope,
-  prefix = "",
-): CommandInfo[] {
-  if (!existsSync(commandsDir)) return []
-  if (!statSync(commandsDir).isDirectory()) {
-    log(`[command-discovery] Skipping non-directory path: ${commandsDir}`)
-    return []
-  }
-
-  const entries = readdirSync(commandsDir, { withFileTypes: true })
-  const commands: CommandInfo[] = []
-
-  for (const entry of entries) {
-    if (entry.isDirectory()) {
-      if (entry.name.startsWith(".")) continue
-      const nestedPrefix = prefix
-        ? `${prefix}${NESTED_COMMAND_SEPARATOR}${entry.name}`
-        : entry.name
-      commands.push(
-        ...discoverCommandsFromDir(join(commandsDir, entry.name), scope, nestedPrefix),
-      )
-      continue
-    }
-
-    if (!isMarkdownFile(entry)) continue
-
-    const commandPath = join(commandsDir, entry.name)
-    const baseCommandName = basename(entry.name, ".md")
-    const commandName = prefix
-      ? `${prefix}${NESTED_COMMAND_SEPARATOR}${baseCommandName}`
-      : baseCommandName
-
-    try {
-      const content = readFileSync(commandPath, "utf-8")
-      const { data, body } = parseFrontmatter<CommandFrontmatter>(content)
-
-      const isOpencodeSource = scope === "opencode" || scope === "opencode-project"
-      const metadata: CommandMetadata = {
-        name: commandName,
-        description: data.description || "",
-        argumentHint: data["argument-hint"],
-        model: sanitizeModelField(data.model, isOpencodeSource ? "opencode" : "claude-code"),
-        agent: data.agent,
-        subtask: Boolean(data.subtask),
-      }
-
-      commands.push({
-        name: commandName,
-        path: commandPath,
-        metadata,
-        content: body,
-        scope,
-      })
-    } catch {
-      continue
-    }
-  }
-
-  return commands
-}
-
-function discoverPluginCommands(options?: CommandDiscoveryOptions): CommandInfo[] {
-  const pluginDefinitions = discoverPluginCommandDefinitions(options)
-
-  return Object.entries(pluginDefinitions).map(([name, definition]) => ({
-    name,
-    metadata: {
-      name,
-      description: definition.description || "",
-      model: definition.model,
-      agent: definition.agent,
-      subtask: definition.subtask,
-    },
-    content: definition.template,
-    scope: "plugin",
-  }))
-}
-
-function deduplicateCommandInfosByName(commands: CommandInfo[]): CommandInfo[] {
-  const seen = new Set<string>()
-  const deduplicatedCommands: CommandInfo[] = []
-
-  for (const command of commands) {
-    if (seen.has(command.name)) {
-      continue
-    }
-
-    seen.add(command.name)
-    deduplicatedCommands.push(command)
-  }
-
-  return deduplicatedCommands
-}
-
-export function discoverCommandsSync(
-  directory?: string,
-  options?: CommandDiscoveryOptions,
-): CommandInfo[] {
-  const userCommandsDir = join(getClaudeConfigDir(), "commands")
-  const projectCommandsDir = join(directory ?? process.cwd(), ".claude", "commands")
-  const opencodeGlobalDirs = getOpenCodeCommandDirs({ binary: "opencode" })
-  const opencodeProjectDirs = findProjectOpencodeCommandDirs(directory ?? process.cwd())
-
-  const userCommands = discoverCommandsFromDir(userCommandsDir, "user")
-  const opencodeGlobalCommands = opencodeGlobalDirs.flatMap((commandsDir) =>
-    discoverCommandsFromDir(commandsDir, "opencode")
-  )
-  const projectCommands = discoverCommandsFromDir(projectCommandsDir, "project")
-  const opencodeProjectCommands = opencodeProjectDirs.flatMap((commandsDir) =>
-    discoverCommandsFromDir(commandsDir, "opencode-project"),
-  )
-  const pluginCommands = discoverPluginCommands(options)
-
-  const builtinCommandsMap = loadBuiltinCommands()
-  const builtinCommands: CommandInfo[] = Object.values(builtinCommandsMap).map((command) => ({
-    name: command.name,
-    metadata: {
-      name: command.name,
-      description: command.description || "",
-      argumentHint: command.argumentHint,
-      model: command.model,
-      agent: command.agent,
-      subtask: command.subtask,
-    },
-    content: command.template,
-    scope: "builtin",
-  }))
-
-  return deduplicateCommandInfosByName([
-    ...projectCommands,
-    ...userCommands,
-    ...opencodeProjectCommands,
-    ...opencodeGlobalCommands,
-    ...builtinCommands,
-    ...pluginCommands,
-  ])
-}

package/src/tools/slashcommand/command-output-formatter.ts

@@ -1,75 +0,0 @@
-import { dirname } from "path"
-import { resolveCommandsInText, resolveFileReferencesInText } from "../../shared"
-import type { CommandInfo } from "./types"
-
-export async function formatLoadedCommand(
-  command: CommandInfo,
-  userMessage?: string
-): Promise<string> {
-  const sections: string[] = []
-
-  sections.push(`# /${command.name} Command\n`)
-
-  if (command.metadata.description) {
-    sections.push(`**Description**: ${command.metadata.description}\n`)
-  }
-
-  if (command.metadata.argumentHint) {
-    sections.push(`**Usage**: /${command.name} ${command.metadata.argumentHint}\n`)
-  }
-
-  if (userMessage) {
-    sections.push(`**Arguments**: ${userMessage}\n`)
-  }
-
-  if (command.metadata.model) {
-    sections.push(`**Model**: ${command.metadata.model}\n`)
-  }
-
-  if (command.metadata.agent) {
-    sections.push(`**Agent**: ${command.metadata.agent}\n`)
-  }
-
-  if (command.metadata.subtask) {
-    sections.push("**Subtask**: true\n")
-  }
-
-  sections.push(`**Scope**: ${command.scope}\n`)
-  sections.push("---\n")
-  sections.push("## Command Instructions\n")
-
-  let content = command.content || ""
-  if (!content && command.lazyContentLoader) {
-    content = await command.lazyContentLoader.load()
-  }
-
-  const commandDir = command.path ? dirname(command.path) : process.cwd()
-  const withFileReferences = await resolveFileReferencesInText(content, commandDir)
-  const resolvedContent = await resolveCommandsInText(withFileReferences)
-
-  let finalContent = resolvedContent.trim()
-  if (userMessage) {
-    finalContent = finalContent
-      .replace(/\$\{user_message\}/g, userMessage)
-      .replace(/\$ARGUMENTS/g, userMessage)
-  }
-
-  sections.push(finalContent)
-  return sections.join("\n")
-}
-
-export function formatCommandList(items: CommandInfo[]): string {
-  if (items.length === 0) return "No commands or skills found."
-
-  const lines = ["# Available Commands & Skills\n"]
-
-  for (const command of items) {
-    const hint = command.metadata.argumentHint ? ` ${command.metadata.argumentHint}` : ""
-    lines.push(
-      `- **/${command.name}${hint}**: ${command.metadata.description || "(no description)"} (${command.scope})`
-    )
-  }
-
-  lines.push(`\n**Total**: ${items.length} items`)
-  return lines.join("\n")
-}

package/src/tools/slashcommand/index.ts

@@ -1,2 +0,0 @@
-export * from "./types"
-export { discoverCommandsSync } from "./command-discovery"

package/src/tools/slashcommand/types.ts

@@ -1,21 +0,0 @@
-import type { LazyContentLoader } from "../../features/opencode-skill-loader"
-
-export type CommandScope = "builtin" | "config" | "user" | "project" | "opencode" | "opencode-project" | "plugin"
-
-export interface CommandMetadata {
-  name: string
-  description: string
-  argumentHint?: string
-  model?: string
-  agent?: string
-  subtask?: boolean
-}
-
-export interface CommandInfo {
-  name: string
-  path?: string
-  metadata: CommandMetadata
-  content?: string
-  scope: CommandScope
-  lazyContentLoader?: LazyContentLoader
-}

package/src/tools/task/index.ts

@@ -1,7 +0,0 @@
-export { createTaskCreateTool } from "./task-create"
-export { createTaskGetTool } from "./task-get"
-export { createTaskList } from "./task-list"
-export { createTaskUpdateTool } from "./task-update"
-export { syncTaskToTodo, syncAllTasksToTodos } from "./todo-sync"
-export type { TaskObject, TaskStatus, TaskCreateInput, TaskListInput, TaskGetInput, TaskUpdateInput, TaskDeleteInput } from "./types"
-export type { TodoInfo } from "./todo-sync"

package/src/tools/task/task-create.ts

@@ -1,113 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
-import { join } from "path";
-import type { HiaiOpenCodeConfig } from "../../config/schema";
-import type { TaskObject } from "./types";
-import { TaskObjectSchema, TaskCreateInputSchema } from "./types";
-import {
-  getTaskDir,
-  writeJsonAtomic,
-  acquireLock,
-  generateTaskId,
-} from "../../features/claude-tasks/storage";
-import { syncTaskTodoUpdate } from "./todo-sync";
-
-export function createTaskCreateTool(
-  config: Partial<HiaiOpenCodeConfig>,
-  ctx?: PluginInput,
-): ToolDefinition {
-   return tool({
-     description: `Create a new task with auto-generated ID and threadID recording.
-
-Auto-generates T-{uuid} ID, records threadID from context, sets status to "pending".
-Returns minimal response with task ID and subject.
-
-**IMPORTANT - Dependency Planning for Parallel Execution:**
-Use \`blockedBy\` to specify task IDs that must complete before this task can start.
-Calculate dependencies carefully to maximize parallel execution:
-- Tasks with no dependencies can run simultaneously
-- Only block a task if it truly depends on another's output
-- Minimize dependency chains to reduce sequential bottlenecks`,
-     args: {
-      subject: tool.schema.string().describe("Task subject (required)"),
-      description: tool.schema.string().optional().describe("Task description"),
-      activeForm: tool.schema
-        .string()
-        .optional()
-        .describe("Active form (present continuous)"),
-      metadata: tool.schema
-        .record(tool.schema.string(), tool.schema.unknown())
-        .optional()
-        .describe("Task metadata"),
-      blockedBy: tool.schema
-        .array(tool.schema.string())
-        .optional()
-        .describe("Task IDs blocking this task"),
-      blocks: tool.schema
-        .array(tool.schema.string())
-        .optional()
-        .describe("Task IDs this task blocks"),
-      repoURL: tool.schema.string().optional().describe("Repository URL"),
-      parentID: tool.schema.string().optional().describe("Parent task ID"),
-    },
-    execute: async (args, context) => {
-      return handleCreate(args, config, ctx, context);
-    },
-  });
-}
-
-async function handleCreate(
-  args: Record<string, unknown>,
-  config: Partial<HiaiOpenCodeConfig>,
-  ctx: PluginInput | undefined,
-  context: { sessionID: string },
-): Promise<string> {
-  try {
-    const validatedArgs = TaskCreateInputSchema.parse(args);
-    const taskDir = getTaskDir(config);
-    const lock = acquireLock(taskDir);
-
-    if (!lock.acquired) {
-      return JSON.stringify({ error: "task_lock_unavailable" });
-    }
-
-    try {
-      const taskId = generateTaskId();
-      const task: TaskObject = {
-        id: taskId,
-        subject: validatedArgs.subject,
-        description: validatedArgs.description ?? "",
-        status: "pending",
-        blocks: validatedArgs.blocks ?? [],
-        blockedBy: validatedArgs.blockedBy ?? [],
-        activeForm: validatedArgs.activeForm,
-        metadata: validatedArgs.metadata,
-        repoURL: validatedArgs.repoURL,
-        parentID: validatedArgs.parentID,
-        threadID: context.sessionID,
-      };
-
-      const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(join(taskDir, `${taskId}.json`), validatedTask);
-
-      await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
-
-      return JSON.stringify({
-        task: {
-          id: validatedTask.id,
-          subject: validatedTask.subject,
-        },
-      });
-    } finally {
-      lock.release();
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Required")) {
-      return JSON.stringify({
-        error: "validation_error",
-        message: error.message,
-      });
-    }
-    return JSON.stringify({ error: "internal_error" });
-  }
-}

package/src/tools/task/task-get.ts

@@ -1,47 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { join } from "path"
-import type { HiaiOpenCodeConfig } from "../../config/schema"
-import { TaskGetInputSchema, TaskObjectSchema } from "./types"
-import { getTaskDir, readJsonSafe } from "../../features/claude-tasks/storage"
-
-const TASK_ID_PATTERN = /^T-[A-Za-z0-9-]+$/
-
-function parseTaskId(id: string): string | null {
-  if (!TASK_ID_PATTERN.test(id)) return null
-  return id
-}
-
-export function createTaskGetTool(config: Partial<HiaiOpenCodeConfig>): ToolDefinition {
-  return tool({
-    description: `Retrieve a task by ID.
-
-Returns the full task object including all fields: id, subject, description, status, activeForm, blocks, blockedBy, owner, metadata, repoURL, parentID, and threadID.
-
-Returns null if the task does not exist or the file is invalid.`,
-    args: {
-      id: tool.schema.string().describe("Task ID to retrieve (format: T-{uuid})"),
-    },
-    execute: async (args: Record<string, unknown>): Promise<string> => {
-      try {
-        const validatedArgs = TaskGetInputSchema.parse(args)
-        const taskId = parseTaskId(validatedArgs.id)
-
-        if (!taskId) {
-          return JSON.stringify({ error: "invalid_task_id" })
-        }
-
-        const taskDir = getTaskDir(config)
-        const taskPath = join(taskDir, `${taskId}.json`)
-
-         const task = readJsonSafe(taskPath, TaskObjectSchema)
-
-        return JSON.stringify({ task: task ?? null })
-      } catch (error) {
-        if (error instanceof Error && error.message.includes("validation")) {
-          return JSON.stringify({ error: "invalid_arguments" })
-        }
-        return JSON.stringify({ error: "unknown_error" })
-      }
-    },
-  })
-}

package/src/tools/task/task-list.ts

@@ -1,79 +0,0 @@
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool"
-import { join } from "path"
-import { existsSync, readdirSync } from "fs"
-import type { HiaiOpenCodeConfig } from "../../config/schema"
-import type { TaskObject, TaskStatus } from "./types"
-import { TaskObjectSchema } from "./types"
-import { readJsonSafe, getTaskDir } from "../../features/claude-tasks/storage"
-
-interface TaskSummary {
-  id: string
-  subject: string
-  status: TaskStatus
-  owner?: string
-  blockedBy: string[]
-}
-
-export function createTaskList(config: Partial<HiaiOpenCodeConfig>): ToolDefinition {
-  return tool({
-    description: `List all active tasks with summary information.
-    
-Returns tasks excluding completed and deleted statuses by default.
-For each task's blockedBy field, filters to only include unresolved (non-completed) blockers.
-Returns summary format: id, subject, status, owner, blockedBy (not full description).`,
-    args: {},
-    execute: async (): Promise<string> => {
-      const taskDir = getTaskDir(config)
-
-      if (!existsSync(taskDir)) {
-        return JSON.stringify({ tasks: [] })
-      }
-
-      const files = readdirSync(taskDir)
-        .filter((f) => f.endsWith(".json") && f.startsWith("T-"))
-        .map((f) => f.replace(".json", ""))
-
-      if (files.length === 0) {
-        return JSON.stringify({ tasks: [] })
-      }
-
-      const allTasks: TaskObject[] = []
-      for (const fileId of files) {
-        const task = readJsonSafe(join(taskDir, `${fileId}.json`), TaskObjectSchema)
-        if (task) {
-          allTasks.push(task)
-        }
-      }
-
-      const taskMap = new Map(allTasks.map((t) => [t.id, t]))
-
-      // Filter out completed and deleted tasks
-      const activeTasks = allTasks.filter(
-        (task) => task.status !== "completed" && task.status !== "deleted"
-      )
-
-      // Build summary with filtered blockedBy
-      const summaries: TaskSummary[] = activeTasks.map((task) => {
-        // Filter blockedBy to only include unresolved (non-completed) blockers
-        const unresolvedBlockers = task.blockedBy.filter((blockerId: string) => {
-          const blockerTask = taskMap.get(blockerId)
-          // Include if blocker doesn't exist (missing) or if it's not completed
-          return !blockerTask || blockerTask.status !== "completed"
-        })
-
-        return {
-          id: task.id,
-          subject: task.subject,
-          status: task.status,
-          owner: task.owner,
-          blockedBy: unresolvedBlockers,
-        }
-      })
-
-       return JSON.stringify({
-         tasks: summaries,
-         reminder: "1 task = 1 task. Maximize parallel execution by running independent tasks (tasks with empty blockedBy) concurrently."
-       })
-    },
-  })
-}

package/src/tools/task/task-update.ts

@@ -1,152 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin";
-import { tool, type ToolDefinition } from "@opencode-ai/plugin/tool";
-import { join } from "path";
-import type { HiaiOpenCodeConfig } from "../../config/schema";
-import { TaskObjectSchema, TaskUpdateInputSchema } from "./types";
-import {
-  getTaskDir,
-  readJsonSafe,
-  writeJsonAtomic,
-  acquireLock,
-} from "../../features/claude-tasks/storage";
-import { syncTaskTodoUpdate } from "./todo-sync";
-
-const TASK_ID_PATTERN = /^T-[A-Za-z0-9-]+$/;
-
-function parseTaskId(id: string): string | null {
-  if (!TASK_ID_PATTERN.test(id)) return null;
-  return id;
-}
-
-export function createTaskUpdateTool(
-  config: Partial<HiaiOpenCodeConfig>,
-  ctx?: PluginInput,
-): ToolDefinition {
-   return tool({
-     description: `Update an existing task with new values.
-
-Supports updating: subject, description, status, activeForm, owner, metadata.
-For blocks/blockedBy: use addBlocks/addBlockedBy to append (additive, not replacement).
-For metadata: merge with existing, set key to null to delete.
-Syncs to OpenCode Todo API after update.
-
-**IMPORTANT - Dependency Management:**
-Use \`addBlockedBy\` to declare dependencies on other tasks.
-Properly managed dependencies enable maximum parallel execution.`,
-     args: {
-      id: tool.schema.string().describe("Task ID (required)"),
-      subject: tool.schema.string().optional().describe("Task subject"),
-      description: tool.schema.string().optional().describe("Task description"),
-      status: tool.schema
-        .enum(["pending", "in_progress", "completed", "deleted"])
-        .optional()
-        .describe("Task status"),
-      activeForm: tool.schema
-        .string()
-        .optional()
-        .describe("Active form (present continuous)"),
-      owner: tool.schema
-        .string()
-        .optional()
-        .describe("Task owner (agent name)"),
-      addBlocks: tool.schema
-        .array(tool.schema.string())
-        .optional()
-        .describe("Task IDs to add to blocks (additive, not replacement)"),
-      addBlockedBy: tool.schema
-        .array(tool.schema.string())
-        .optional()
-        .describe("Task IDs to add to blockedBy (additive, not replacement)"),
-      metadata: tool.schema
-        .record(tool.schema.string(), tool.schema.unknown())
-        .optional()
-        .describe("Task metadata to merge (set key to null to delete)"),
-    },
-    execute: async (args, context) => {
-      return handleUpdate(args, config, ctx, context);
-    },
-  });
-}
-
-async function handleUpdate(
-  args: Record<string, unknown>,
-  config: Partial<HiaiOpenCodeConfig>,
-  ctx: PluginInput | undefined,
-  context: { sessionID: string },
-): Promise<string> {
-  try {
-    const validatedArgs = TaskUpdateInputSchema.parse(args);
-    const taskId = parseTaskId(validatedArgs.id);
-    if (!taskId) {
-      return JSON.stringify({ error: "invalid_task_id" });
-    }
-
-    const taskDir = getTaskDir(config);
-    const lock = acquireLock(taskDir);
-
-    if (!lock.acquired) {
-      return JSON.stringify({ error: "task_lock_unavailable" });
-    }
-
-    try {
-      const taskPath = join(taskDir, `${taskId}.json`);
-      const task = readJsonSafe(taskPath, TaskObjectSchema);
-
-      if (!task) {
-        return JSON.stringify({ error: "task_not_found" });
-      }
-
-      if (validatedArgs.subject !== undefined) {
-        task.subject = validatedArgs.subject;
-      }
-      if (validatedArgs.description !== undefined) {
-        task.description = validatedArgs.description;
-      }
-      if (validatedArgs.status !== undefined) {
-        task.status = validatedArgs.status;
-      }
-      if (validatedArgs.activeForm !== undefined) {
-        task.activeForm = validatedArgs.activeForm;
-      }
-      if (validatedArgs.owner !== undefined) {
-        task.owner = validatedArgs.owner;
-      }
-
-      const addBlocks = args.addBlocks as string[] | undefined;
-      if (addBlocks) {
-        task.blocks = [...new Set([...task.blocks, ...addBlocks])];
-      }
-
-      const addBlockedBy = args.addBlockedBy as string[] | undefined;
-      if (addBlockedBy) {
-        task.blockedBy = [...new Set([...task.blockedBy, ...addBlockedBy])];
-      }
-
-      if (validatedArgs.metadata !== undefined) {
-        task.metadata = { ...task.metadata, ...validatedArgs.metadata };
-        Object.keys(task.metadata).forEach((key) => {
-          if (task.metadata?.[key] === null) {
-            delete task.metadata[key];
-          }
-        });
-      }
-
-      const validatedTask = TaskObjectSchema.parse(task);
-      writeJsonAtomic(taskPath, validatedTask);
-
-      await syncTaskTodoUpdate(ctx, validatedTask, context.sessionID);
-
-      return JSON.stringify({ task: validatedTask });
-    } finally {
-      lock.release();
-    }
-  } catch (error) {
-    if (error instanceof Error && error.message.includes("Required")) {
-      return JSON.stringify({
-        error: "validation_error",
-        message: error.message,
-      });
-    }
-    return JSON.stringify({ error: "internal_error" });
-  }
-}