@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/internals/plugins/subtask2/loop.ts

@@ -1,122 +0,0 @@
-import type { LoopConfig } from "./types";
-
-export interface LoopState {
-  config: LoopConfig;
-  iteration: number;
-  commandName: string;
-  arguments: string;
-  model?: string;
-  agent?: string;
-  deferredReturns?: string[];
-}
-
-// Track active retry loops by session ID
-const activeLoops = new Map<string, LoopState>();
-
-// Track sessions pending loop evaluation (after subtask returns, main LLM evaluates)
-const pendingLoopEvaluation = new Map<string, LoopState>();
-
-// Re-export from prompts.ts
-export {
-  loopEvaluationPrompt as createEvaluationPrompt,
-  loopYieldPrompt as createYieldPrompt,
-} from "./utils/prompts";
-
-/**
- * Parse the main LLM's response for loop decision
- * Only looks for break signal: <subtask2 loop=break/>, <subtask2 loop="break"/>, <subtask2 loop='break'/>
- * If no break signal found, loop continues by default (until max iterations)
- */
-export function parseLoopDecision(output: string): "break" | "continue" {
-  const match = output.match(/<subtask2\s+loop=["']?break["']?\s*\/?>/i);
-  return match ? "break" : "continue";
-}
-
-/**
- * Start tracking a retry loop for a session
- */
-export function startLoop(
-  sessionId: string,
-  config: LoopConfig,
-  commandName: string,
-  args: string,
-  model?: string,
-  agent?: string,
-  deferredReturns?: string[]
-): void {
-  activeLoops.set(sessionId, {
-    config,
-    iteration: 1,
-    commandName,
-    arguments: args,
-    model,
-    agent,
-    deferredReturns,
-  });
-}
-
-/**
- * Get current retry state for a session
- */
-export function getLoopState(sessionId: string): LoopState | undefined {
-  return activeLoops.get(sessionId);
-}
-
-/**
- * Increment iteration count
- */
-export function incrementLoopIteration(sessionId: string): number {
-  const state = activeLoops.get(sessionId);
-  if (state) {
-    state.iteration++;
-    return state.iteration;
-  }
-  return 0;
-}
-
-/**
- * Clear retry loop for a session
- */
-export function clearLoop(sessionId: string): void {
-  activeLoops.delete(sessionId);
-}
-
-/**
- * Check if we've hit max iterations
- */
-export function isMaxIterationsReached(sessionId: string): boolean {
-  const state = activeLoops.get(sessionId);
-  if (!state) return true;
-  return state.iteration >= state.config.max;
-}
-
-/**
- * Set pending evaluation state (after subtask completes, before main LLM evaluates)
- */
-export function setPendingEvaluation(
-  sessionId: string,
-  state: LoopState
-): void {
-  pendingLoopEvaluation.set(sessionId, state);
-}
-
-/**
- * Get pending evaluation state
- */
-export function getPendingEvaluation(sessionId: string): LoopState | undefined {
-  return pendingLoopEvaluation.get(sessionId);
-}
-
-/**
- * Get all pending evaluations (for iteration in hooks)
- */
-export function getAllPendingEvaluations(): Map<string, LoopState> {
-  return pendingLoopEvaluation;
-}
-
-/**
- * Clear pending evaluation
- */
-export function clearPendingEvaluation(sessionId: string): void {
-  pendingLoopEvaluation.delete(sessionId);
-}

package/src/internals/plugins/subtask2/parsing/auto.ts

@@ -1,33 +0,0 @@
-/**
- * Parse auto workflow output from LLM response (POC)
- */
-
-export interface AutoWorkflowResult {
-  found: boolean;
-  command?: string; // The full /subtask {...} command
-}
-
-/**
- * Extract the workflow command from <subtask2 auto="true">...</subtask2> tags
- */
-export function parseAutoWorkflowOutput(text: string): AutoWorkflowResult {
-  const regex =
-    /<subtask2\s+auto\s*=\s*["']?true["']?\s*>([\s\S]*?)<\/subtask2>/i;
-  const match = text.match(regex);
-
-  if (!match || !match[1]) {
-    return { found: false };
-  }
-
-  const content = match[1].trim();
-
-  // Validate it starts with /subtask
-  if (!content.toLowerCase().startsWith("/subtask")) {
-    return { found: false };
-  }
-
-  return {
-    found: true,
-    command: content,
-  };
-}

package/src/internals/plugins/subtask2/parsing/commands.ts

@@ -1,154 +0,0 @@
-import { parseOverridesString, type CommandOverrides } from "./overrides";
-
-export interface ParsedCommand {
-  command: string;
-  arguments?: string;
-  overrides: CommandOverrides;
-  isInlineSubtask?: boolean; // true for /subtask {...} prompt syntax
-}
-
-/**
- * Parse a command string with optional overrides: /cmd {model:provider/model-id} args
- * Also supports inline subtask syntax: /subtask {loop:5,until:condition} prompt text
- * Syntax: /command {key:value,key2:value2} arguments
- * (No-space form is also supported for compatibility.)
- */
-export function parseCommandWithOverrides(input: string): ParsedCommand {
-  const trimmed = input.trim();
-
-  if (!trimmed.startsWith("/")) {
-    return { command: trimmed, overrides: {} };
-  }
-
-  // Check for inline subtask syntax: /subtask {...} prompt (case-insensitive)
-  const subtaskMatch = trimmed.match(/^\/[sS][uU][bB][tT][aA][sS][kK]\b/s);
-  if (subtaskMatch) {
-    const rest = trimmed.slice(subtaskMatch[0].length).trimStart();
-    if (rest.startsWith("{")) {
-      const inlineParsed = parseInlineSubtask(rest);
-      if (inlineParsed) {
-        return {
-          command: "", // No command - inline prompt
-          arguments: inlineParsed.prompt,
-          overrides: inlineParsed.overrides,
-          isInlineSubtask: true,
-        };
-      }
-    }
-  }
-
-  // Match: /command {overrides} or /command
-  const match = trimmed.match(/^\/([a-zA-Z0-9_\-\/]+)(.*)$/s);
-
-  if (!match) {
-    // Fallback: just split on first space
-    const [cmd, ...rest] = trimmed.slice(1).split(/\s+/);
-    return {
-      command: cmd,
-      arguments: rest.join(" ") || undefined,
-      overrides: {},
-    };
-  }
-
-  const [, commandName, rawRest] = match;
-  const rest = rawRest || "";
-  const trimmedRest = rest.trimStart();
-  let overrides: CommandOverrides = {};
-  let args = trimmedRest;
-
-  if (trimmedRest.startsWith("{")) {
-    const extracted = extractOverrideBlock(trimmedRest);
-    if (extracted) {
-      overrides = parseOverridesString(extracted.overrideStr);
-      args = extracted.rest.trimStart();
-    }
-  }
-
-  return {
-    command: commandName,
-    arguments: args || undefined,
-    overrides,
-  };
-}
-
-export interface ParsedInlineSubtask {
-  prompt: string;
-  overrides: CommandOverrides;
-}
-
-export interface ParsedArgsWithOverrides {
-  overrides: CommandOverrides;
-  rest: string;
-}
-
-/**
- * Parse /subtask {...} prompt inline subtask syntax
- * Input should NOT include the /subtask prefix
- * Returns null if not valid inline subtask syntax
- */
-export function parseInlineSubtask(input: string): ParsedInlineSubtask | null {
-  const trimmed = input.trim();
-
-  // Must start with {
-  if (!trimmed.startsWith("{")) return null;
-
-  const extracted = extractOverrideBlock(trimmed);
-  if (!extracted) return null;
-
-  const overrideStr = extracted.overrideStr;
-  const prompt = extracted.rest.trim();
-
-  if (!prompt) return null;
-
-  // Reuse centralized override parsing logic
-  const overrides = parseOverridesString(overrideStr);
-
-  return { prompt, overrides };
-}
-
-/**
- * Parse a leading override block from arguments ("{...} rest")
- */
-export function parseOverridesFromArgs(
-  input: string
-): ParsedArgsWithOverrides | null {
-  const trimmed = input.trimStart();
-  if (!trimmed.startsWith("{")) return null;
-
-  const extracted = extractOverrideBlock(trimmed);
-  if (!extracted) return null;
-
-  const overrides = parseOverridesString(extracted.overrideStr);
-  const rest = extracted.rest.trimStart();
-  return { overrides, rest };
-}
-
-function extractOverrideBlock(
-  input: string
-): { overrideStr: string; rest: string } | null {
-  if (!input.startsWith("{")) return null;
-
-  // Find matching closing brace (handle nested braces)
-  let depth = 0;
-  let braceEnd = -1;
-  for (let i = 0; i < input.length; i++) {
-    if (input[i] === "{") {
-      depth++;
-    } else if (input[i] === "}") {
-      depth--;
-      if (depth === 0) {
-        braceEnd = i;
-        break;
-      }
-    }
-  }
-
-  if (braceEnd === -1) return null;
-
-  const overrideStr = input.substring(1, braceEnd);
-  const rest = input.substring(braceEnd + 1);
-  return { overrideStr, rest };
-}
-
-// Re-export CommandOverrides for convenience
-export type { CommandOverrides };

package/src/internals/plugins/subtask2/parsing/frontmatter.ts

@@ -1,20 +0,0 @@
-import YAML from "yaml";
-
-/**
- * Parsing: YAML frontmatter extraction
- */
-
-export function parseFrontmatter(content: string): Record<string, unknown> {
-  const match = content.match(/^---\n([\s\S]*?)\n---/);
-  if (!match) return {};
-  try {
-    return YAML.parse(match[1]) ?? {};
-  } catch {
-    return {};
-  }
-}
-
-export function getTemplateBody(content: string): string {
-  const match = content.match(/^---\n[\s\S]*?\n---\n([\s\S]*)$/);
-  return match ? match[1].trim() : content.trim();
-}

package/src/internals/plugins/subtask2/parsing/index.ts

@@ -1,10 +0,0 @@
-/**
- * Parsing module - re-exports all parsing functionality
- */
-
-export * from "./frontmatter";
-export * from "./overrides";
-export * from "./commands";
-export * from "./turns";
-export * from "./parallel";
-export * from "./auto";

package/src/internals/plugins/subtask2/parsing/overrides.ts

@@ -1,68 +0,0 @@
-import type { LoopConfig } from "../types";
-
-export interface CommandOverrides {
-  model?: string;
-  agent?: string;
-  loop?: LoopConfig;
-  return?: string[];
-  parallel?: string[];
-  as?: string; // Named result identifier for $RESULT[name] references
-  auto?: boolean; // Auto workflow mode - LLM generates workflow dynamically
-}
-
-/**
- * Parse overrides string like "model:foo/bar && loop:10 && until:condition"
- * Uses && as separator between parameters
- * Uses || as separator for multi-value parameters (return, parallel)
- */
-export function parseOverridesString(overridesStr: string): CommandOverrides {
-  const overrides: CommandOverrides = {};
-
-  // Parse key:value pairs separated by &&
-  const pairs = overridesStr.split("&&").map(s => s.trim());
-  for (const pair of pairs) {
-    const colonIdx = pair.indexOf(":");
-    if (colonIdx > 0) {
-      const key = pair.slice(0, colonIdx).trim();
-      const value = pair.slice(colonIdx + 1).trim();
-      if (key === "model") {
-        overrides.model = value;
-      } else if (key === "agent") {
-        overrides.agent = value;
-      } else if (key === "loop") {
-        // loop:10 - just max iterations, no until marker
-        const max = parseInt(value, 10);
-        if (!isNaN(max) && max > 0) {
-          overrides.loop = { max, until: "" };
-        }
-      } else if (key === "until") {
-        // until:condition - set/update until marker
-        if (!overrides.loop) {
-          overrides.loop = { max: 10, until: value }; // default max=10
-        } else {
-          overrides.loop.until = value;
-        }
-      } else if (key === "return") {
-        // return:first || second || third - split on || for multiple returns
-        overrides.return = value
-          .split("||")
-          .map(s => s.trim())
-          .filter(s => s.length > 0);
-      } else if (key === "parallel") {
-        // parallel:/cmd1 args || /cmd2 args - split on || for multiple parallels
-        overrides.parallel = value
-          .split("||")
-          .map(s => s.trim())
-          .filter(s => s.length > 0);
-      } else if (key === "as") {
-        // as:name - named result identifier
-        overrides.as = value;
-      } else if (key === "auto") {
-        // auto:true - enable auto workflow mode
-        overrides.auto = value === "true";
-      }
-    }
-  }
-
-  return overrides;
-}

package/src/internals/plugins/subtask2/parsing/parallel.ts

@@ -1,91 +0,0 @@
-import type { ParallelCommand, LoopConfig } from "../types";
-import { parseCommandWithOverrides } from "./commands";
-
-/**
- * Parse loop config from frontmatter
- * Supports:
- *   loop: 10  (just max)
- *   loop: { max: 10, until: "condition" }
- */
-export function parseLoopConfig(loop: unknown): LoopConfig | undefined {
-  if (loop === undefined || loop === null) return undefined;
-
-  if (typeof loop === "number" && loop > 0) {
-    return { max: loop, until: "" };
-  }
-
-  if (typeof loop === "object") {
-    const obj = loop as Record<string, unknown>;
-    const max = typeof obj.max === "number" ? obj.max : 10;
-    const until = typeof obj.until === "string" ? obj.until : "";
-    if (max > 0) {
-      return { max, until };
-    }
-  }
-
-  return undefined;
-}
-
-// Parse a parallel item - handles "/cmd {model:...} args" syntax, plain "cmd", or {command, arguments} object
-function isParallelCommandLike(p: unknown): p is { command: unknown; arguments?: unknown; prompt?: unknown; model?: unknown; agent?: unknown; loop?: unknown; as?: unknown; inline?: unknown } {
-  return typeof p === "object" && p !== null && "command" in p
-}
-
-export function parseParallelItem(p: unknown): ParallelCommand | null {
-  if (typeof p === "string") {
-    const trimmed = p.trim();
-    if (trimmed.startsWith("/")) {
-      const parsed = parseCommandWithOverrides(trimmed);
-      if (parsed.isInlineSubtask) {
-        return {
-          command: "_inline_subtask_",
-          inline: true,
-          prompt: parsed.arguments,
-          model: parsed.overrides.model,
-          agent: parsed.overrides.agent,
-          loop: parsed.overrides.loop,
-          as: parsed.overrides.as,
-        };
-      }
-      return {
-        command: parsed.command,
-        arguments: parsed.arguments,
-        model: parsed.overrides.model,
-        agent: parsed.overrides.agent,
-        loop: parsed.overrides.loop,
-        as: parsed.overrides.as,
-      };
-    }
-    return { command: trimmed };
-  }
-  if (isParallelCommandLike(p)) {
-    return {
-      command: String(p.command),
-      arguments: p.arguments !== undefined ? String(p.arguments) : undefined,
-      prompt: p.prompt !== undefined ? String(p.prompt) : undefined,
-      model: p.model !== undefined ? String(p.model) : undefined,
-      agent: p.agent !== undefined ? String(p.agent) : undefined,
-      loop: p.loop !== undefined ? parseLoopConfig(p.loop) : undefined,
-      as: p.as !== undefined ? String(p.as) : undefined,
-      inline: p.inline !== undefined ? Boolean(p.inline) : undefined,
-    };
-  }
-  return null;
-}
-
-export function parseParallelConfig(parallel: unknown): ParallelCommand[] {
-  if (!parallel) return [];
-  if (Array.isArray(parallel)) {
-    return parallel
-      .map(parseParallelItem)
-      .filter((p): p is ParallelCommand => p !== null);
-  }
-  if (typeof parallel === "string") {
-    // Split by comma, parse each
-    return parallel
-      .split(",")
-      .map(parseParallelItem)
-      .filter((p): p is ParallelCommand => p !== null);
-  }
-  return [];
-}

package/src/internals/plugins/subtask2/parsing/turns.ts

@@ -1,78 +0,0 @@
-/**
- * Parsing: $TURN[n] reference extraction and manipulation
- */
-
-// $TURN[n] - last n messages
-// $TURN[:n] or $TURN[:n:m:o] - specific messages at indices (1-based from end)
-const TURN_LAST_N_PATTERN = "\\$TURN\\[(\\d+)\\]";
-const TURN_SPECIFIC_PATTERN = "\\$TURN\\[([:\\d]+)\\]";
-
-export type TurnReference =
-  | { type: "lastN"; match: string; count: number }
-  | { type: "specific"; match: string; indices: number[] }
-  | { type: "all"; match: string };
-
-/**
- * Extract all $TURN references from a string
- * - $TURN[n] -> last n messages
- * - $TURN[:n] or $TURN[:2:5:8] -> specific indices (1-based from end)
- */
-export function extractTurnReferences(text: string): TurnReference[] {
-  const refs: TurnReference[] = [];
-
-  // Match $TURN[...] patterns
-  const regex = /\$TURN\[([^\]]+)\]/g;
-  let match: RegExpExecArray | null;
-
-  while ((match = regex.exec(text)) !== null) {
-    const inner = match[1];
-
-    if (inner === "*") {
-      // All messages: $TURN[*]
-      refs.push({ type: "all", match: match[0] });
-    } else if (inner.startsWith(":")) {
-      // Specific indices: $TURN[:2] or $TURN[:2:5:8]
-      const indices = inner
-        .split(":")
-        .filter(Boolean)
-        .map(n => parseInt(n, 10));
-      if (indices.length > 0 && indices.every(n => !isNaN(n))) {
-        refs.push({ type: "specific", match: match[0], indices });
-      }
-    } else {
-      // Last N: $TURN[5]
-      const count = parseInt(inner, 10);
-      if (!isNaN(count)) {
-        refs.push({ type: "lastN", match: match[0], count });
-      }
-    }
-  }
-  return refs;
-}
-
-/**
- * Check if text contains any $TURN references
- */
-export function hasTurnReferences(text: string): boolean {
-  return /\$TURN\[[^\]]+\]/.test(text);
-}
-
-/**
- * Replace all $TURN references in text with the provided content map
- */
-export function replaceTurnReferences(
-  text: string,
-  replacements: Map<string, string>
-): string {
-  let result = text;
-  for (const [pattern, replacement] of replacements) {
-    result = result.replaceAll(pattern, replacement);
-  }
-  return result;
-}
-
-// Keep old names as aliases for backward compat during transition
-export const extractSessionReferences = extractTurnReferences;
-export const hasSessionReferences = hasTurnReferences;
-export const replaceSessionReferences = replaceTurnReferences;
-export type SessionReference = TurnReference;

package/src/internals/plugins/subtask2/types.ts

@@ -1,41 +0,0 @@
-export interface LoopConfig {
-  max: number; // Max iterations
-  until: string; // Completion condition
-}
-
-export interface ParallelCommand {
-  command: string;
-  arguments?: string;
-  prompt?: string;
-  model?: string; // Override model: "provider/model-id"
-  agent?: string;
-  loop?: LoopConfig; // Retry until completion
-  as?: string; // Named result identifier for $RESULT[name] references
-  inline?: boolean;
-}
-
-export interface CommandConfig {
-  return: string[];
-  parallel: ParallelCommand[];
-  agent?: string;
-  description?: string;
-  template?: string;
-  loop?: LoopConfig;
-  model?: string;
-  auto?: boolean; // subtask2: auto mode - LLM generates workflow dynamically
-}
-
-export interface Subtask2Config {
-  replace_generic: boolean;
-  generic_return?: string;
-}
-
-export interface SubtaskPart {
-  type: "subtask";
-  agent: string;
-  model?: { providerID: string; modelID: string };
-  description: string;
-  command: string;
-  prompt: string;
-  as?: string; // Named result identifier for $RESULT[name] references
-}