micode 0.8.3 → 0.8.5

package/src/octto/ui/index.ts

@@ -0,0 +1,2 @@
+// src/octto/ui/index.ts
+export { getHtmlBundle } from "./bundle";

package/src/tools/artifact-index/index.ts

@@ -1,9 +1,8 @@
 // src/tools/artifact-index/index.ts
 import { Database } from "bun:sqlite";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { mkdirSync, existsSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
+import { dirname, join } from "node:path";
 
 const DEFAULT_DB_DIR = join(homedir(), ".config", "opencode", "artifact-index");
 const DB_NAME = "context.db";
@@ -27,6 +26,16 @@ export interface LedgerRecord {
   filesModified?: string;
 }
 
+export interface MilestoneArtifactRecord {
+  id: string;
+  milestoneId: string;
+  artifactType: string;
+  sourceSessionId?: string;
+  createdAt?: string;
+  tags?: string[];
+  payload: string;
+}
+
 export interface SearchResult {
   type: "plan" | "ledger";
   id: string;
@@ -36,6 +45,18 @@ export interface SearchResult {
   score: number;
 }
 
+export interface MilestoneArtifactSearchResult {
+  type: "milestone";
+  id: string;
+  milestoneId: string;
+  artifactType: string;
+  sourceSessionId?: string;
+  createdAt?: string;
+  tags: string[];
+  payload: string;
+  score: number;
+}
+
 export class ArtifactIndex {
   private db: Database | null = null;
   private dbPath: string;
@@ -91,8 +112,26 @@ export class ArtifactIndex {
         created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
         indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
       );
+      CREATE TABLE IF NOT EXISTS milestone_artifacts (
+        id TEXT PRIMARY KEY,
+        milestone_id TEXT NOT NULL,
+        artifact_type TEXT NOT NULL,
+        source_session_id TEXT,
+        created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+        tags TEXT,
+        payload TEXT NOT NULL,
+        indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+      );
       CREATE VIRTUAL TABLE IF NOT EXISTS plans_fts USING fts5(id, title, overview, approach);
       CREATE VIRTUAL TABLE IF NOT EXISTS ledgers_fts USING fts5(id, session_name, goal, state_now, key_decisions);
+      CREATE VIRTUAL TABLE IF NOT EXISTS milestone_artifacts_fts USING fts5(
+        id,
+        milestone_id,
+        artifact_type,
+        payload,
+        tags,
+        source_session_id
+      );
     `;
   }
 
@@ -239,6 +278,116 @@ export class ArtifactIndex {
     return results.slice(0, limit);
   }
 
+  async indexMilestoneArtifact(record: MilestoneArtifactRecord): Promise<void> {
+    if (!this.db) throw new Error("Database not initialized");
+
+    const tags = JSON.stringify(record.tags ?? []);
+    const createdAt = record.createdAt ?? new Date().toISOString();
+    const existing = this.db.query("SELECT id FROM milestone_artifacts WHERE id = ?").get(record.id) as
+      | { id: string }
+      | undefined;
+
+    if (existing) {
+      this.db.run("DELETE FROM milestone_artifacts_fts WHERE id = ?", [existing.id]);
+    }
+
+    this.db.run(
+      `INSERT INTO milestone_artifacts (
+          id,
+          milestone_id,
+          artifact_type,
+          source_session_id,
+          created_at,
+          tags,
+          payload,
+          indexed_at
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP)
+        ON CONFLICT(id) DO UPDATE SET
+          milestone_id = excluded.milestone_id,
+          artifact_type = excluded.artifact_type,
+          source_session_id = excluded.source_session_id,
+          created_at = excluded.created_at,
+          tags = excluded.tags,
+          payload = excluded.payload,
+          indexed_at = CURRENT_TIMESTAMP`,
+      [
+        record.id,
+        record.milestoneId,
+        record.artifactType,
+        record.sourceSessionId ?? null,
+        createdAt,
+        tags,
+        record.payload,
+      ],
+    );
+
+    this.db.run(
+      `INSERT INTO milestone_artifacts_fts (
+          id,
+          milestone_id,
+          artifact_type,
+          payload,
+          tags,
+          source_session_id
+        ) VALUES (?, ?, ?, ?, ?, ?)`,
+      [record.id, record.milestoneId, record.artifactType, record.payload, tags, record.sourceSessionId ?? ""],
+    );
+  }
+
+  async searchMilestoneArtifacts(
+    query: string,
+    options: { milestoneId?: string; artifactType?: string; limit?: number } = {},
+  ): Promise<MilestoneArtifactSearchResult[]> {
+    if (!this.db) throw new Error("Database not initialized");
+
+    const escapedQuery = this.escapeFtsQuery(query);
+    const milestoneId = options.milestoneId ?? null;
+    const artifactType = options.artifactType ?? null;
+    const limit = options.limit ?? 10;
+
+    const rows = this.db
+      .query(
+        `SELECT
+          milestone_artifacts.id,
+          milestone_artifacts.milestone_id,
+          milestone_artifacts.artifact_type,
+          milestone_artifacts.source_session_id,
+          milestone_artifacts.created_at,
+          milestone_artifacts.tags,
+          milestone_artifacts.payload,
+          milestone_artifacts_fts.rank
+        FROM milestone_artifacts_fts
+        JOIN milestone_artifacts ON milestone_artifacts.id = milestone_artifacts_fts.id
+        WHERE milestone_artifacts_fts MATCH ?
+          AND (? IS NULL OR milestone_artifacts.milestone_id = ?)
+          AND (? IS NULL OR milestone_artifacts.artifact_type = ?)
+        ORDER BY milestone_artifacts_fts.rank
+        LIMIT ?`,
+      )
+      .all(escapedQuery, milestoneId, milestoneId, artifactType, artifactType, limit) as Array<{
+      id: string;
+      milestone_id: string;
+      artifact_type: string;
+      source_session_id: string | null;
+      created_at: string | null;
+      tags: string | null;
+      payload: string;
+      rank: number;
+    }>;
+
+    return rows.map((row) => ({
+      type: "milestone",
+      id: row.id,
+      milestoneId: row.milestone_id,
+      artifactType: row.artifact_type,
+      sourceSessionId: row.source_session_id ?? undefined,
+      createdAt: row.created_at ?? undefined,
+      tags: row.tags ? JSON.parse(row.tags) : [],
+      payload: row.payload,
+      score: -row.rank,
+    }));
+  }
+
   private escapeFtsQuery(query: string): string {
     // Escape special FTS5 characters and wrap terms in quotes
     return query

package/src/tools/artifact-index/schema.sql

@@ -27,6 +27,18 @@ CREATE TABLE IF NOT EXISTS ledgers (
     indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 );
 
+-- Milestone artifacts table
+CREATE TABLE IF NOT EXISTS milestone_artifacts (
+    id TEXT PRIMARY KEY,
+    milestone_id TEXT NOT NULL,
+    artifact_type TEXT NOT NULL,
+    source_session_id TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    tags TEXT,
+    payload TEXT NOT NULL,
+    indexed_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
 -- FTS5 virtual tables for full-text search (standalone, manually synced)
 CREATE VIRTUAL TABLE IF NOT EXISTS plans_fts USING fts5(
     id,
@@ -42,3 +54,12 @@ CREATE VIRTUAL TABLE IF NOT EXISTS ledgers_fts USING fts5(
     state_now,
     key_decisions
 );
+
+CREATE VIRTUAL TABLE IF NOT EXISTS milestone_artifacts_fts USING fts5(
+    id,
+    milestone_id,
+    artifact_type,
+    payload,
+    tags,
+    source_session_id
+);

package/src/tools/milestone-artifact-search.ts

@@ -0,0 +1,48 @@
+import { tool } from "@opencode-ai/plugin/tool";
+
+import { getArtifactIndex } from "./artifact-index";
+
+const ARTIFACT_TYPES = ["feature", "decision", "session"] as const;
+
+export const milestone_artifact_search = tool({
+  description: `Search milestone-driven artifacts stored in SQLite.
+Use this to find feature, decision, or session artifacts for a specific milestone.
+Returns ranked results filtered by milestone metadata.`,
+  args: {
+    query: tool.schema.string().describe("Search query for milestone artifacts"),
+    milestone_id: tool.schema.string().optional().describe("Optional milestone identifier to filter results"),
+    artifact_type: tool.schema.enum(ARTIFACT_TYPES).optional().describe("Optional artifact type to filter results"),
+    limit: tool.schema.number().optional().describe("Max results to return (default: 10)"),
+  },
+  execute: async (args) => {
+    try {
+      const index = await getArtifactIndex();
+      const results = await index.searchMilestoneArtifacts(args.query, {
+        milestoneId: args.milestone_id,
+        artifactType: args.artifact_type,
+        limit: args.limit,
+      });
+
+      if (results.length === 0) {
+        return "No milestone artifact results found for that query.";
+      }
+
+      let output = `## Milestone Artifact Search Results\n\nFound ${results.length} result(s).\n\n`;
+
+      for (const result of results) {
+        const tags = result.tags.length ? result.tags.join(", ") : "none";
+        output += `### ${result.milestoneId} · ${result.artifactType}\n`;
+        output += `- ID: ${result.id}\n`;
+        output += `- Source Session: ${result.sourceSessionId ?? "unknown"}\n`;
+        output += `- Created: ${result.createdAt ?? "unknown"}\n`;
+        output += `- Tags: ${tags}\n`;
+        output += `- Payload: ${result.payload}\n`;
+        output += `- Score: ${result.score.toFixed(2)}\n\n`;
+      }
+
+      return output;
+    } catch (error) {
+      return `Error searching milestone artifacts: ${error instanceof Error ? error.message : String(error)}`;
+    }
+  },
+});

package/src/tools/octto/brainstorm.ts

@@ -0,0 +1,332 @@
+// src/tools/octto/brainstorm.ts
+import { tool } from "@opencode-ai/plugin/tool";
+
+import type { ReviewAnswer, SessionStore } from "../../octto/session";
+import { QUESTION_TYPES, QUESTIONS, STATUSES } from "../../octto/session";
+import { BRANCH_STATUSES, type BrainstormState, createStateStore, type StateStore } from "../../octto/state";
+import { config } from "../../utils/config";
+import { log } from "../../utils/logger";
+import { formatBranchStatus, formatFindings, formatFindingsList, formatQASummary } from "./formatters";
+import { processAnswer } from "./processor";
+import type { OcttoSessionTracker, OcttoTools, OpencodeClient } from "./types";
+import { generateSessionId } from "./utils";
+
+// --- Extracted helper functions ---
+
+interface CollectionResult {
+  state: BrainstormState | null;
+  allComplete: boolean;
+}
+
+async function collectAnswers(
+  stateStore: StateStore,
+  sessions: SessionStore,
+  sessionId: string,
+  browserSessionId: string,
+  client: OpencodeClient,
+): Promise<CollectionResult> {
+  const pendingProcessing: Promise<void>[] = [];
+
+  for (let i = 0; i < config.octto.maxIterations; i++) {
+    if (await stateStore.isSessionComplete(sessionId)) break;
+
+    const answer = await sessions.getNextAnswer({
+      session_id: browserSessionId,
+      block: true,
+      timeout: config.octto.answerTimeoutMs,
+    });
+
+    if (!answer.completed) {
+      if (answer.status === STATUSES.NONE_PENDING) {
+        await Promise.all(pendingProcessing);
+        pendingProcessing.length = 0;
+        continue;
+      }
+      if (answer.status === STATUSES.TIMEOUT) break;
+      continue;
+    }
+
+    const { question_id, response } = answer;
+    if (!question_id || response === undefined) continue;
+
+    const processing = processAnswer(
+      stateStore,
+      sessions,
+      sessionId,
+      browserSessionId,
+      question_id,
+      response,
+      client,
+    ).catch((error) => {
+      log.error("octto", `Error processing answer ${question_id}`, error);
+    });
+    pendingProcessing.push(processing);
+  }
+
+  await Promise.all(pendingProcessing);
+
+  const [state, allComplete] = await Promise.all([
+    stateStore.getSession(sessionId),
+    stateStore.isSessionComplete(sessionId),
+  ]);
+
+  return { state, allComplete };
+}
+
+interface ReviewSection {
+  id: string;
+  title: string;
+  content: string;
+}
+
+function buildReviewSections(state: BrainstormState): ReviewSection[] {
+  return [
+    {
+      id: "summary",
+      title: "Original Request",
+      content: state.request,
+    },
+    ...state.branch_order.map((id) => {
+      const b = state.branches[id];
+      const qaSummary = formatQASummary(b);
+      return {
+        id,
+        title: b.scope,
+        content: `**Finding:** ${b.finding || "No finding"}\n\n**Discussion:**\n${qaSummary || "(no questions answered)"}`,
+      };
+    }),
+  ];
+}
+
+interface ReviewResult {
+  approved: boolean;
+  feedback: string;
+}
+
+async function waitForReviewApproval(sessions: SessionStore, browserSessionId: string): Promise<ReviewResult> {
+  const result = await sessions.getNextAnswer({
+    session_id: browserSessionId,
+    block: true,
+    timeout: config.octto.reviewTimeoutMs,
+  });
+
+  if (!result.completed || !result.response) {
+    return { approved: false, feedback: "" };
+  }
+
+  const response = result.response as ReviewAnswer;
+  return {
+    approved: response.decision === "approve",
+    feedback: response.feedback ?? "",
+  };
+}
+
+// --- Format functions ---
+
+function formatInProgressResult(state: BrainstormState): string {
+  const branches = state.branch_order.map((id) => formatBranchStatus(state.branches[id])).join("\n");
+  return `<brainstorm_in_progress>
+  <request>${state.request}</request>
+  <branches>
+${branches}
+  </branches>
+  <next_action>Call await_brainstorm_complete again to continue</next_action>
+</brainstorm_in_progress>`;
+}
+
+function formatSkippedReviewResult(state: BrainstormState): string {
+  return `<brainstorm_complete status="review_skipped">
+  <request>${state.request}</request>
+  <branch_count>${state.branch_order.length}</branch_count>
+  <note>Browser session ended before review</note>
+  ${formatFindings(state)}
+  <next_action>Write the design document to thoughts/shared/designs/</next_action>
+</brainstorm_complete>`;
+}
+
+function formatCompletionResult(state: BrainstormState, approved: boolean, feedback: string): string {
+  const feedbackXml = feedback ? `\n  <feedback>${feedback}</feedback>` : "";
+  const nextAction = approved
+    ? "Write the design document to thoughts/shared/designs/"
+    : "Review feedback and discuss with user before proceeding";
+  return `<brainstorm_complete status="${approved ? "approved" : "changes_requested"}">
+  <request>${state.request}</request>
+  <branch_count>${state.branch_order.length}</branch_count>${feedbackXml}
+  ${formatFindings(state)}
+  <next_action>${nextAction}</next_action>
+</brainstorm_complete>`;
+}
+
+// --- Tool definitions ---
+
+export function createBrainstormTools(
+  sessions: SessionStore,
+  client: OpencodeClient,
+  tracker?: OcttoSessionTracker,
+): OcttoTools {
+  const store = createStateStore();
+
+  const create_brainstorm = tool({
+    description: "Create a new brainstorm session with exploration branches",
+    args: {
+      request: tool.schema.string().describe("The original user request"),
+      branches: tool.schema
+        .array(
+          tool.schema.object({
+            id: tool.schema.string(),
+            scope: tool.schema.string(),
+            initial_question: tool.schema.object({
+              type: tool.schema.enum(QUESTION_TYPES),
+              config: tool.schema.looseObject({
+                question: tool.schema.string().optional(),
+                context: tool.schema.string().optional(),
+              }),
+            }),
+          }),
+        )
+        .describe("Branches to explore"),
+    },
+    execute: async (args, context) => {
+      const sessionId = generateSessionId();
+
+      await store.createSession(
+        sessionId,
+        args.request,
+        args.branches.map((b) => ({ id: b.id, scope: b.scope })),
+      );
+
+      const initialQuestions = args.branches.map((b) => {
+        const { type, config } = b.initial_question;
+        const context = `[${b.scope}] ${config.context ?? ""}`.trim();
+        return {
+          type,
+          config: { ...config, context },
+        };
+      });
+
+      const browserSession = await sessions.startSession({
+        title: "Brainstorming Session",
+        questions: initialQuestions,
+      });
+
+      tracker?.onCreated?.(context.sessionID, browserSession.session_id);
+      await store.setBrowserSessionId(sessionId, browserSession.session_id);
+
+      for (const [i, branch] of args.branches.entries()) {
+        const questionId = browserSession.question_ids?.[i];
+        if (!questionId) continue;
+
+        const { type, config } = branch.initial_question;
+        await store.addQuestionToBranch(sessionId, branch.id, {
+          id: questionId,
+          type,
+          text: config.question ?? "Question",
+          config,
+        });
+      }
+
+      const branchesXml = args.branches.map((b) => `    <branch id="${b.id}">${b.scope}</branch>`).join("\n");
+      return `<brainstorm_created>
+  <session_id>${sessionId}</session_id>
+  <browser_session>${browserSession.session_id}</browser_session>
+  <url>${browserSession.url}</url>
+  <branches>
+${branchesXml}
+  </branches>
+  <next_action>Call get_next_answer(session_id="${browserSession.session_id}", block=true)</next_action>
+</brainstorm_created>`;
+    },
+  });
+
+  const get_session_summary = tool({
+    description: "Get summary of all branches and their findings",
+    args: {
+      session_id: tool.schema.string().describe("Brainstorm session ID"),
+    },
+    execute: async (args) => {
+      const state = await store.getSession(args.session_id);
+      if (!state) return `<error>Session not found: ${args.session_id}</error>`;
+
+      const branches = state.branch_order.map((id) => formatBranchStatus(state.branches[id])).join("\n");
+      const allDone = Object.values(state.branches).every((b) => b.status === BRANCH_STATUSES.DONE);
+
+      return `<session_summary>
+  <request>${state.request}</request>
+  <status>${allDone ? "complete" : "in_progress"}</status>
+  <branches>
+${branches}
+  </branches>
+</session_summary>`;
+    },
+  });
+
+  const end_brainstorm = tool({
+    description: "End a brainstorm session and get final summary",
+    args: {
+      session_id: tool.schema.string().describe("Brainstorm session ID"),
+    },
+    execute: async (args, context) => {
+      const state = await store.getSession(args.session_id);
+      if (!state) return `<error>Session not found: ${args.session_id}</error>`;
+
+      if (state.browser_session_id) {
+        const result = await sessions.endSession(state.browser_session_id);
+        if (result.ok) {
+          tracker?.onEnded?.(context.sessionID, state.browser_session_id);
+        }
+      }
+
+      const findings = formatFindingsList(state);
+      await store.deleteSession(args.session_id);
+
+      return `<brainstorm_ended>
+  <request>${state.request}</request>
+  ${findings}
+  <next_action>Write the design document based on these findings to thoughts/shared/designs/</next_action>
+</brainstorm_ended>`;
+    },
+  });
+
+  const await_brainstorm_complete = tool({
+    description: `Wait for brainstorm session to complete. Processes answers asynchronously as they arrive.
+Returns when all branches are done with their findings.
+This is the recommended way to run a brainstorm - just create_brainstorm then await_brainstorm_complete.`,
+    args: {
+      session_id: tool.schema.string().describe("Brainstorm session ID (state session)"),
+      browser_session_id: tool.schema.string().describe("Browser session ID (for collecting answers)"),
+    },
+    execute: async (args) => {
+      const { state, allComplete } = await collectAnswers(
+        store,
+        sessions,
+        args.session_id,
+        args.browser_session_id,
+        client,
+      );
+
+      if (!state) return "<error>Session lost</error>";
+      if (!allComplete) return formatInProgressResult(state);
+
+      const sections = buildReviewSections(state);
+
+      try {
+        sessions.pushQuestion(args.browser_session_id, QUESTIONS.SHOW_PLAN, {
+          question: "Review Design Plan",
+          sections,
+        });
+      } catch {
+        return formatSkippedReviewResult(state);
+      }
+
+      const { approved, feedback } = await waitForReviewApproval(sessions, args.browser_session_id);
+      return formatCompletionResult(state, approved, feedback);
+    },
+  });
+
+  return {
+    create_brainstorm,
+    get_session_summary,
+    end_brainstorm,
+    await_brainstorm_complete,
+  };
+}

package/src/tools/octto/extractor.ts

@@ -0,0 +1,95 @@
+// src/tools/octto/extractor.ts
+// Utility functions for extracting answer summaries
+
+import type {
+  Answer,
+  AskCodeAnswer,
+  AskTextAnswer,
+  ConfirmAnswer,
+  EmojiReactAnswer,
+  PickManyAnswer,
+  PickOneAnswer,
+  QuestionType,
+  RankAnswer,
+  RateAnswer,
+  ReviewAnswer,
+  ShowOptionsAnswer,
+  SliderAnswer,
+  ThumbsAnswer,
+} from "../../octto/session";
+import { QUESTIONS } from "../../octto/session";
+
+const MAX_TEXT_LENGTH = 100;
+
+function truncateText(text: string): string {
+  return text.length > MAX_TEXT_LENGTH ? `${text.substring(0, MAX_TEXT_LENGTH)}...` : text;
+}
+
+export function extractAnswerSummary(type: QuestionType, answer: Answer): string {
+  switch (type) {
+    case QUESTIONS.PICK_ONE:
+      return (answer as PickOneAnswer).selected;
+
+    case QUESTIONS.PICK_MANY:
+      return (answer as PickManyAnswer).selected.join(", ");
+
+    case QUESTIONS.CONFIRM:
+      return (answer as ConfirmAnswer).choice;
+
+    case QUESTIONS.THUMBS:
+      return (answer as ThumbsAnswer).choice;
+
+    case QUESTIONS.EMOJI_REACT:
+      return (answer as EmojiReactAnswer).emoji;
+
+    case QUESTIONS.ASK_TEXT:
+      return truncateText((answer as AskTextAnswer).text);
+
+    case QUESTIONS.SLIDER:
+      return String((answer as SliderAnswer).value);
+
+    case QUESTIONS.RANK: {
+      const rankAnswer = answer as RankAnswer;
+      const sorted = [...rankAnswer.ranking].sort((a, b) => a.rank - b.rank);
+      return sorted.map((r) => r.id).join(" → ");
+    }
+
+    case QUESTIONS.RATE: {
+      const rateAnswer = answer as RateAnswer;
+      const entries = Object.entries(rateAnswer.ratings);
+      if (entries.length === 0) return "no ratings";
+      const sorted = entries.sort((a, b) => b[1] - a[1]);
+      return sorted
+        .slice(0, 3)
+        .map(([k, v]) => `${k}: ${v}`)
+        .join(", ");
+    }
+
+    case QUESTIONS.ASK_CODE:
+      return truncateText((answer as AskCodeAnswer).code);
+
+    case QUESTIONS.ASK_IMAGE:
+    case QUESTIONS.ASK_FILE:
+      return "file(s) uploaded";
+
+    case QUESTIONS.SHOW_DIFF:
+    case QUESTIONS.SHOW_PLAN:
+    case QUESTIONS.REVIEW_SECTION: {
+      const reviewAnswer = answer as ReviewAnswer;
+      return reviewAnswer.feedback
+        ? `${reviewAnswer.decision}: ${truncateText(reviewAnswer.feedback)}`
+        : reviewAnswer.decision;
+    }
+
+    case QUESTIONS.SHOW_OPTIONS: {
+      const optAnswer = answer as ShowOptionsAnswer;
+      return optAnswer.feedback ? `${optAnswer.selected}: ${truncateText(optAnswer.feedback)}` : optAnswer.selected;
+    }
+
+    default: {
+      // Exhaustiveness check - if we get here, we missed a case
+      const _exhaustive: never = type;
+      return String(_exhaustive);
+    }
+  }
+}