micode 0.8.4 → 0.8.6

package/src/tools/octto/factory.ts

@@ -0,0 +1,89 @@
+// src/tools/octto/factory.ts
+
+import { tool } from "@opencode-ai/plugin/tool";
+
+import type { BaseConfig, QuestionType, SessionStore } from "../../octto/session";
+import type { OcttoTool, OcttoTools } from "./types";
+
+type ArgsSchema = Parameters<typeof tool>[0]["args"];
+
+interface QuestionToolConfig<T> {
+  type: QuestionType;
+  description: string;
+  args: ArgsSchema;
+  validate?: (args: T) => string | null;
+  toConfig: (args: T) => BaseConfig;
+}
+
+export function createQuestionToolFactory(sessions: SessionStore) {
+  return function createQuestionTool<T extends { session_id: string }>(config: QuestionToolConfig<T>): OcttoTool {
+    return tool({
+      description: `${config.description}
+Returns immediately with question_id. Use get_answer to retrieve response.`,
+      args: {
+        session_id: tool.schema.string().describe("Session ID from start_session"),
+        ...config.args,
+      },
+      execute: async (args) => {
+        const validationError = config.validate?.(args as unknown as T);
+        if (validationError) return `Failed: ${validationError}`;
+
+        try {
+          const questionConfig = config.toConfig(args as unknown as T);
+          const result = sessions.pushQuestion(args.session_id, config.type, questionConfig);
+          return `Question pushed: ${result.question_id}\nUse get_answer("${result.question_id}") to retrieve response.`;
+        } catch (error) {
+          return `Failed: ${error instanceof Error ? error.message : String(error)}`;
+        }
+      },
+    });
+  };
+}
+
+export function createPushQuestionTool(sessions: SessionStore): OcttoTools {
+  const push_question = tool({
+    description: `Push a question to the session queue. This is the generic tool for adding any question type.
+The question will appear in the browser for the user to answer.`,
+    args: {
+      session_id: tool.schema.string().describe("Session ID from start_session"),
+      type: tool.schema
+        .enum([
+          "pick_one",
+          "pick_many",
+          "confirm",
+          "ask_text",
+          "ask_image",
+          "ask_file",
+          "ask_code",
+          "show_diff",
+          "show_plan",
+          "show_options",
+          "review_section",
+          "thumbs",
+          "slider",
+          "rank",
+          "rate",
+          "emoji_react",
+        ])
+        .describe("Question type"),
+      config: tool.schema
+        .looseObject({
+          question: tool.schema.string().optional(),
+          context: tool.schema.string().optional(),
+        })
+        .describe("Question configuration (varies by type)"),
+    },
+    execute: async (args) => {
+      try {
+        const result = sessions.pushQuestion(args.session_id, args.type, args.config);
+        return `Question pushed: ${result.question_id}
+Type: ${args.type}
+Use get_next_answer(session_id, block=true) to wait for the user's response.`;
+      } catch (error) {
+        return `Failed to push question: ${error instanceof Error ? error.message : String(error)}`;
+      }
+    },
+  });
+
+  return { push_question };
+}

package/src/tools/octto/formatters.ts

@@ -0,0 +1,63 @@
+// src/tools/octto/formatters.ts
+
+import type { Answer } from "../../octto/session";
+import type { BrainstormState, Branch, BranchQuestion } from "../../octto/state";
+import { extractAnswerSummary } from "./extractor";
+
+function escapeXml(str: string): string {
+  return str
+    .replace(/&/g, "&")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&apos;");
+}
+
+export function formatBranchFinding(branch: Branch): string {
+  return `<branch id="${branch.id}">
+    <scope>${escapeXml(branch.scope)}</scope>
+    <finding>${escapeXml(branch.finding || "no finding")}</finding>
+  </branch>`;
+}
+
+export function formatBranchStatus(branch: Branch): string {
+  return `<branch id="${branch.id}" status="${branch.status}">
+    <scope>${escapeXml(branch.scope)}</scope>
+    <finding>${escapeXml(branch.finding || "pending")}</finding>
+  </branch>`;
+}
+
+export function formatFindings(state: BrainstormState): string {
+  const branches = state.branch_order.map((id) => formatBranchFinding(state.branches[id])).join("\n");
+  return `<findings>\n${branches}\n</findings>`;
+}
+
+export function formatFindingsList(state: BrainstormState): string {
+  const items = state.branch_order
+    .map((id) => {
+      const b = state.branches[id];
+      return `  <finding scope="${escapeXml(b.scope)}">${escapeXml(b.finding || "no finding")}</finding>`;
+    })
+    .join("\n");
+  return `<findings>\n${items}\n</findings>`;
+}
+
+export function formatQASummary(branch: Branch): string {
+  const answered = branch.questions.filter((q): q is BranchQuestion & { answer: Answer } => q.answer !== undefined);
+
+  if (answered.length === 0) {
+    return "<qa_summary>no questions answered</qa_summary>";
+  }
+
+  const qas = answered
+    .map((q) => {
+      const answerText = extractAnswerSummary(q.type, q.answer);
+      return `    <qa>
+      <question>${escapeXml(q.text)}</question>
+      <answer>${escapeXml(answerText)}</answer>
+    </qa>`;
+    })
+    .join("\n");
+
+  return qas;
+}

package/src/tools/octto/index.ts

@@ -0,0 +1,27 @@
+// src/tools/octto/index.ts
+
+import type { SessionStore } from "../../octto/session";
+import { createBrainstormTools } from "./brainstorm";
+import { createPushQuestionTool } from "./factory";
+import { createQuestionTools } from "./questions";
+import { createResponseTools } from "./responses";
+import { createSessionTools } from "./session";
+import type { OcttoSessionTracker, OcttoTools, OpencodeClient } from "./types";
+
+export type { SessionStore } from "../../octto/session";
+export { createSessionStore } from "../../octto/session";
+export type { OcttoSessionTracker, OcttoTools, OpencodeClient } from "./types";
+
+export function createOcttoTools(
+  sessions: SessionStore,
+  client: OpencodeClient,
+  tracker?: OcttoSessionTracker,
+): OcttoTools {
+  return {
+    ...createSessionTools(sessions, tracker),
+    ...createQuestionTools(sessions),
+    ...createResponseTools(sessions),
+    ...createPushQuestionTool(sessions),
+    ...createBrainstormTools(sessions, client, tracker),
+  };
+}

package/src/tools/octto/processor.ts

@@ -0,0 +1,165 @@
+// src/tools/octto/processor.ts
+
+import type { Answer, QuestionType, SessionStore } from "../../octto/session";
+import { BRANCH_STATUSES, type BrainstormState, type StateStore } from "../../octto/state";
+import { log } from "../../utils/logger";
+
+import type { OpencodeClient } from "./types";
+
+// Agent name constant - matches the agent exported from src/agents/probe.ts
+const PROBE_AGENT = "probe";
+
+interface ProbeResult {
+  done: boolean;
+  finding?: string;
+  question?: {
+    type: QuestionType;
+    config: Record<string, unknown>;
+  };
+}
+
+function formatBranchContext(state: BrainstormState, branchId: string): string {
+  const lines: string[] = [];
+
+  lines.push(`<original_request>${state.request}</original_request>`);
+  lines.push("");
+  lines.push("<branches>");
+
+  for (const [id, branch] of Object.entries(state.branches)) {
+    const isCurrent = id === branchId;
+    lines.push(`<branch id="${id}" scope="${branch.scope}"${isCurrent ? ' current="true"' : ""}>`);
+
+    for (const q of branch.questions) {
+      lines.push(`  <question type="${q.type}">${q.text}</question>`);
+      if (q.answer) {
+        lines.push(`  <answer>${JSON.stringify(q.answer)}</answer>`);
+      }
+    }
+
+    if (branch.status === BRANCH_STATUSES.DONE && branch.finding) {
+      lines.push(`  <finding>${branch.finding}</finding>`);
+    }
+
+    lines.push("</branch>");
+  }
+
+  lines.push("</branches>");
+  lines.push("");
+  lines.push(`Evaluate the branch "${branchId}" and decide: ask another question or complete with a finding.`);
+
+  return lines.join("\n");
+}
+
+async function runProbeAgent(client: OpencodeClient, state: BrainstormState, branchId: string): Promise<ProbeResult> {
+  const sessionResult = await client.session.create({
+    body: { title: `probe-${branchId}` },
+  });
+
+  if (!sessionResult.data) {
+    throw new Error("Failed to create probe session");
+  }
+
+  const probeSessionId = sessionResult.data.id;
+
+  try {
+    const promptResult = await client.session.prompt({
+      path: { id: probeSessionId },
+      body: {
+        agent: PROBE_AGENT,
+        tools: {},
+        parts: [{ type: "text", text: formatBranchContext(state, branchId) }],
+      },
+    });
+
+    if (!promptResult.data) {
+      throw new Error("Failed to get probe response");
+    }
+
+    let responseText = "";
+    for (const part of promptResult.data.parts) {
+      if (part.type === "text" && "text" in part) {
+        responseText += (part as { text: string }).text;
+      }
+    }
+
+    const jsonMatch = responseText.match(/\{[\s\S]*\}/);
+    if (!jsonMatch) {
+      return { done: true, finding: "Could not parse probe response" };
+    }
+
+    return JSON.parse(jsonMatch[0]) as ProbeResult;
+  } finally {
+    await client.session.delete({ path: { id: probeSessionId } }).catch(() => {});
+  }
+}
+
+export async function processAnswer(
+  stateStore: StateStore,
+  sessions: SessionStore,
+  sessionId: string,
+  browserSessionId: string,
+  questionId: string,
+  answer: Answer,
+  client: OpencodeClient,
+): Promise<void> {
+  const state = await stateStore.getSession(sessionId);
+  if (!state) return;
+
+  // Find which branch this question belongs to
+  let branchId: string | null = null;
+  for (const [id, branch] of Object.entries(state.branches)) {
+    if (branch.questions.some((q) => q.id === questionId)) {
+      branchId = id;
+      break;
+    }
+  }
+
+  if (!branchId) return;
+  if (state.branches[branchId].status === BRANCH_STATUSES.DONE) return;
+
+  // Record the answer
+  try {
+    await stateStore.recordAnswer(sessionId, questionId, answer);
+  } catch (error) {
+    log.error("octto", `Failed to record answer for ${questionId}`, error);
+    throw error;
+  }
+
+  // Get fresh state after recording
+  const updatedState = await stateStore.getSession(sessionId);
+  if (!updatedState) return;
+
+  const branch = updatedState.branches[branchId];
+  if (!branch || branch.status === BRANCH_STATUSES.DONE) return;
+
+  // Evaluate branch using probe agent
+  const result = await runProbeAgent(client, updatedState, branchId);
+
+  if (result.done) {
+    await stateStore.completeBranch(sessionId, branchId, result.finding || "No finding");
+    return;
+  }
+
+  if (result.question) {
+    const config = result.question.config as { question?: string; context?: string };
+    const questionText = config.question ?? "Follow-up question";
+    const existingContext = config.context ?? "";
+    const configWithContext = {
+      ...config,
+      context: `[${branch.scope}] ${existingContext}`.trim(),
+    };
+
+    const { question_id: newQuestionId } = sessions.pushQuestion(
+      browserSessionId,
+      result.question.type,
+      configWithContext,
+    );
+
+    await stateStore.addQuestionToBranch(sessionId, branchId, {
+      id: newQuestionId,
+      type: result.question.type,
+      text: questionText,
+      config: configWithContext,
+    });
+  }
+}