micode 0.8.3 → 0.8.5

package/src/hooks/ledger-loader.ts

@@ -2,9 +2,7 @@
 import type { PluginInput } from "@opencode-ai/plugin";
 import { readFile, readdir } from "node:fs/promises";
 import { join } from "node:path";
-
-const LEDGER_DIR = "thoughts/ledgers";
-const LEDGER_PREFIX = "CONTINUITY_";
+import { config } from "../utils/config";
 
 export interface LedgerInfo {
   sessionName: string;
@@ -13,11 +11,11 @@ export interface LedgerInfo {
 }
 
 export async function findCurrentLedger(directory: string): Promise<LedgerInfo | null> {
-  const ledgerDir = join(directory, LEDGER_DIR);
+  const ledgerDir = join(directory, config.paths.ledgerDir);
 
   try {
     const files = await readdir(ledgerDir);
-    const ledgerFiles = files.filter((f) => f.startsWith(LEDGER_PREFIX) && f.endsWith(".md"));
+    const ledgerFiles = files.filter((f) => f.startsWith(config.paths.ledgerPrefix) && f.endsWith(".md"));
 
     if (ledgerFiles.length === 0) return null;
 
@@ -40,7 +38,7 @@ export async function findCurrentLedger(directory: string): Promise<LedgerInfo |
 
     const filePath = join(ledgerDir, latestFile);
     const content = await readFile(filePath, "utf-8");
-    const sessionName = latestFile.replace(LEDGER_PREFIX, "").replace(".md", "");
+    const sessionName = latestFile.replace(config.paths.ledgerPrefix, "").replace(".md", "");
 
     return { sessionName, filePath, content };
   } catch {

package/src/hooks/token-aware-truncation.ts

@@ -1,23 +1,17 @@
 import type { PluginInput } from "@opencode-ai/plugin";
+import { config } from "../utils/config";
 
 // Tools that benefit from truncation
 const TRUNCATABLE_TOOLS = ["grep", "Grep", "glob", "Glob", "ast_grep_search"];
 
-// Token estimation (conservative: 4 chars = 1 token)
-const CHARS_PER_TOKEN = 4;
-const DEFAULT_CONTEXT_LIMIT = 200_000;
-const DEFAULT_MAX_OUTPUT_TOKENS = 50_000;
-const SAFETY_MARGIN = 0.5; // Keep 50% headroom
-const PRESERVE_HEADER_LINES = 3;
-
 function estimateTokens(text: string): number {
-  return Math.ceil(text.length / CHARS_PER_TOKEN);
+  return Math.ceil(text.length / config.tokens.charsPerToken);
 }
 
 function truncateToTokenLimit(
   output: string,
   maxTokens: number,
-  preserveLines: number = PRESERVE_HEADER_LINES,
+  preserveLines: number = config.tokens.preserveHeaderLines,
 ): string {
   const currentTokens = estimateTokens(output);
 
@@ -85,7 +79,7 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
 
       const messages = (resp as { data?: unknown[] }).data;
       if (!Array.isArray(messages) || messages.length === 0) {
-        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+        return { used: 0, limit: config.tokens.defaultContextLimit };
       }
 
       // Find last assistant message with usage info
@@ -96,7 +90,7 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
       }) as Record<string, unknown> | undefined;
 
       if (!lastAssistant) {
-        return { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+        return { used: 0, limit: config.tokens.defaultContextLimit };
       }
 
       const info = lastAssistant.info as Record<string, unknown> | undefined;
@@ -107,25 +101,25 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
       const used = inputTokens + cacheRead;
 
       // Get model limit (simplified - use default for now)
-      const limit = DEFAULT_CONTEXT_LIMIT;
+      const limit = config.tokens.defaultContextLimit;
 
       const result = { used, limit };
       state.sessionTokenUsage.set(sessionID, result);
       return result;
     } catch {
-      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: DEFAULT_CONTEXT_LIMIT };
+      return state.sessionTokenUsage.get(sessionID) || { used: 0, limit: config.tokens.defaultContextLimit };
     }
   }
 
   function calculateMaxOutputTokens(used: number, limit: number): number {
     const remaining = limit - used;
-    const available = Math.floor(remaining * SAFETY_MARGIN);
+    const available = Math.floor(remaining * config.tokens.safetyMargin);
 
     if (available <= 0) {
       return 0;
     }
 
-    return Math.min(available, DEFAULT_MAX_OUTPUT_TOKENS);
+    return Math.min(available, config.tokens.defaultMaxOutputTokens);
   }
 
   return {
@@ -180,8 +174,8 @@ export function createTokenAwareTruncationHook(ctx: PluginInput) {
       } catch {
         // On error, apply static truncation as fallback
         const currentTokens = estimateTokens(output.output);
-        if (currentTokens > DEFAULT_MAX_OUTPUT_TOKENS) {
-          output.output = truncateToTokenLimit(output.output, DEFAULT_MAX_OUTPUT_TOKENS);
+        if (currentTokens > config.tokens.defaultMaxOutputTokens) {
+          output.output = truncateToTokenLimit(output.output, config.tokens.defaultMaxOutputTokens);
         }
       }
     },

package/src/index.ts

@@ -3,30 +3,28 @@ import type { McpLocalConfig } from "@opencode-ai/sdk";
 
 // Agents
 import { agents, PRIMARY_AGENT_NAME } from "./agents";
-
-// Tools
-import { ast_grep_search, ast_grep_replace, checkAstGrepAvailable } from "./tools/ast-grep";
-import { btca_ask, checkBtcaAvailable } from "./tools/btca";
-import { look_at } from "./tools/look-at";
-import { artifact_search } from "./tools/artifact-search";
-import { createSpawnAgentTool } from "./tools/spawn-agent";
-
+// Config loader
+import { loadMicodeConfig, mergeAgentConfigs } from "./config-loader";
+import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
 // Hooks
 import { createAutoCompactHook } from "./hooks/auto-compact";
+import { createCommentCheckerHook } from "./hooks/comment-checker";
 import { createContextInjectorHook } from "./hooks/context-injector";
-import { createSessionRecoveryHook } from "./hooks/session-recovery";
-import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
 import { createContextWindowMonitorHook } from "./hooks/context-window-monitor";
-import { createCommentCheckerHook } from "./hooks/comment-checker";
-import { createLedgerLoaderHook } from "./hooks/ledger-loader";
-import { createArtifactAutoIndexHook } from "./hooks/artifact-auto-index";
 import { createFileOpsTrackerHook, getFileOps } from "./hooks/file-ops-tracker";
-
+import { createLedgerLoaderHook } from "./hooks/ledger-loader";
+import { createSessionRecoveryHook } from "./hooks/session-recovery";
+import { createTokenAwareTruncationHook } from "./hooks/token-aware-truncation";
+import { artifact_search } from "./tools/artifact-search";
+// Tools
+import { ast_grep_replace, ast_grep_search, checkAstGrepAvailable } from "./tools/ast-grep";
+import { btca_ask, checkBtcaAvailable } from "./tools/btca";
+import { look_at } from "./tools/look-at";
+import { milestone_artifact_search } from "./tools/milestone-artifact-search";
+import { createOcttoTools, createSessionStore } from "./tools/octto";
 // PTY System
-import { PTYManager, createPtyTools } from "./tools/pty";
-
-// Config loader
-import { loadMicodeConfig, mergeAgentConfigs } from "./config-loader";
+import { createPtyTools, PTYManager } from "./tools/pty";
+import { createSpawnAgentTool } from "./tools/spawn-agent";
 
 // Think mode: detect keywords and enable extended thinking
 const THINK_KEYWORDS = [
@@ -75,7 +73,7 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
     console.warn(`[micode] ${btcaStatus.message}`);
   }
 
-  // Load user config for model overrides
+  // Load user config for temperature/maxTokens overrides (model overrides not supported)
   const userConfig = await loadMicodeConfig();
 
   // Think mode state per session
@@ -99,6 +97,28 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
   // Spawn agent tool (for subagents to spawn other subagents)
   const spawn_agent = createSpawnAgentTool(ctx);
 
+  // Octto (browser-based brainstorming) tools
+  const octtoSessionStore = createSessionStore();
+
+  // Track octto sessions per opencode session for cleanup
+  const octtoSessionsMap = new Map<string, Set<string>>();
+
+  const octtoTools = createOcttoTools(octtoSessionStore, ctx.client, {
+    onCreated: (parentSessionId, octtoSessionId) => {
+      const sessions = octtoSessionsMap.get(parentSessionId) ?? new Set<string>();
+      sessions.add(octtoSessionId);
+      octtoSessionsMap.set(parentSessionId, sessions);
+    },
+    onEnded: (parentSessionId, octtoSessionId) => {
+      const sessions = octtoSessionsMap.get(parentSessionId);
+      if (!sessions) return;
+      sessions.delete(octtoSessionId);
+      if (sessions.size === 0) {
+        octtoSessionsMap.delete(parentSessionId);
+      }
+    },
+  });
+
   return {
     // Tools
     tool: {
@@ -107,8 +127,10 @@ const OpenCodeConfigPlugin: Plugin = async (ctx) => {
       btca_ask,
       look_at,
       artifact_search,
+      milestone_artifact_search,
       spawn_agent,
       ...ptyTools,
+      ...octtoTools,
     },
 
     config: async (config) => {
@@ -292,12 +314,22 @@ IMPORTANT:
     },
 
     event: async ({ event }) => {
-      // Session cleanup (think mode + PTY)
+      // Session cleanup (think mode + PTY + octto)
       if (event.type === "session.deleted") {
         const props = event.properties as { info?: { id?: string } } | undefined;
         if (props?.info?.id) {
-          thinkModeState.delete(props.info.id);
-          ptyManager.cleanupBySession(props.info.id);
+          const sessionId = props.info.id;
+          thinkModeState.delete(sessionId);
+          ptyManager.cleanupBySession(sessionId);
+
+          // Cleanup octto sessions
+          const octtoSessions = octtoSessionsMap.get(sessionId);
+          if (octtoSessions) {
+            for (const octtoSessionId of octtoSessions) {
+              await octtoSessionStore.endSession(octtoSessionId).catch(() => {});
+            }
+            octtoSessionsMap.delete(sessionId);
+          }
         }
       }
 

package/src/indexing/milestone-artifact-classifier.ts

@@ -0,0 +1,26 @@
+export const MILESTONE_ARTIFACT_TYPES = {
+  FEATURE: "feature",
+  DECISION: "decision",
+  SESSION: "session",
+} as const;
+
+export type MilestoneArtifactType = (typeof MILESTONE_ARTIFACT_TYPES)[keyof typeof MILESTONE_ARTIFACT_TYPES];
+
+const FEATURE_HINTS = ["requirement", "implementation", "capability", "scope", "spec"];
+const DECISION_HINTS = ["decision", "decided", "trade-off", "rationale", "chosen"];
+const SESSION_HINTS = ["meeting", "status", "discussion", "notes", "update"];
+
+const matchesAny = (content: string, hints: string[]) => hints.some((hint) => content.includes(hint));
+
+export function classifyMilestoneArtifact(content: string): MilestoneArtifactType {
+  const normalized = content.toLowerCase();
+  const isFeature = matchesAny(normalized, FEATURE_HINTS);
+  const isDecision = matchesAny(normalized, DECISION_HINTS);
+  const isSession = matchesAny(normalized, SESSION_HINTS);
+
+  if (isFeature) return MILESTONE_ARTIFACT_TYPES.FEATURE;
+  if (isDecision) return MILESTONE_ARTIFACT_TYPES.DECISION;
+  if (isSession) return MILESTONE_ARTIFACT_TYPES.SESSION;
+
+  return MILESTONE_ARTIFACT_TYPES.SESSION;
+}

package/src/indexing/milestone-artifact-ingest.ts

@@ -0,0 +1,42 @@
+import { type ArtifactIndex, getArtifactIndex } from "../tools/artifact-index";
+import { log } from "../utils/logger";
+import {
+  classifyMilestoneArtifact,
+  MILESTONE_ARTIFACT_TYPES,
+  type MilestoneArtifactType,
+} from "./milestone-artifact-classifier";
+
+export interface MilestoneArtifactInput {
+  id: string;
+  milestoneId: string;
+  sourceSessionId?: string;
+  createdAt?: string;
+  tags?: string[];
+  payload: string;
+}
+
+export async function ingestMilestoneArtifact(
+  input: MilestoneArtifactInput,
+  index?: ArtifactIndex,
+  classifier: (content: string) => MilestoneArtifactType = classifyMilestoneArtifact,
+): Promise<void> {
+  const artifactIndex = index ?? (await getArtifactIndex());
+  let artifactType: MilestoneArtifactType;
+
+  try {
+    artifactType = classifier(input.payload);
+  } catch (error) {
+    log.error("milestone-ingest", "Failed to classify milestone artifact, defaulting to session", error);
+    artifactType = MILESTONE_ARTIFACT_TYPES.SESSION;
+  }
+
+  await artifactIndex.indexMilestoneArtifact({
+    id: input.id,
+    milestoneId: input.milestoneId,
+    artifactType,
+    sourceSessionId: input.sourceSessionId,
+    createdAt: input.createdAt,
+    tags: input.tags,
+    payload: input.payload,
+  });
+}

package/src/octto/constants.ts

@@ -0,0 +1,20 @@
+// src/octto/constants.ts
+// Re-exports from centralized config for backward compatibility
+// Single source of truth is in src/utils/config.ts
+
+import { config } from "../utils/config";
+
+/** Default timeout for waiting for user answers (5 minutes) */
+export const DEFAULT_ANSWER_TIMEOUT_MS = config.octto.answerTimeoutMs;
+
+/** Default maximum number of follow-up questions per branch */
+export const DEFAULT_MAX_QUESTIONS = config.octto.maxQuestions;
+
+/** Default timeout for brainstorm review (10 minutes) */
+export const DEFAULT_REVIEW_TIMEOUT_MS = config.octto.reviewTimeoutMs;
+
+/** Maximum number of brainstorm iterations */
+export const MAX_ITERATIONS = config.octto.maxIterations;
+
+/** Directory for persisting brainstorm state files */
+export const STATE_DIR = config.octto.stateDir;

package/src/octto/session/browser.ts

@@ -0,0 +1,32 @@
+// src/octto/session/browser.ts
+// Cross-platform browser opener
+
+/**
+ * Opens the default browser to the specified URL.
+ * Detects platform and uses appropriate command.
+ */
+export async function openBrowser(url: string): Promise<void> {
+  const platform = process.platform;
+
+  let command: string[];
+
+  switch (platform) {
+    case "darwin":
+      command = ["open", url];
+      break;
+    case "win32":
+      command = ["cmd", "/c", "start", url];
+      break;
+    default:
+      // Linux and others
+      command = ["xdg-open", url];
+      break;
+  }
+
+  const proc = Bun.spawn(command, {
+    stdout: "ignore",
+    stderr: "ignore",
+  });
+
+  await proc.exited;
+}

package/src/octto/session/index.ts

@@ -0,0 +1,25 @@
+// src/octto/session/index.ts
+export type { SessionStore, SessionStoreOptions } from "./sessions";
+export { createSessionStore } from "./sessions";
+export type {
+  Answer,
+  AskCodeAnswer,
+  AskFileAnswer,
+  AskImageAnswer,
+  AskTextAnswer,
+  BaseConfig,
+  ConfirmAnswer,
+  EmojiReactAnswer,
+  PickManyAnswer,
+  PickOneAnswer,
+  QuestionAnswers,
+  QuestionConfig,
+  QuestionType,
+  RankAnswer,
+  RateAnswer,
+  ReviewAnswer,
+  ShowOptionsAnswer,
+  SliderAnswer,
+  ThumbsAnswer,
+} from "./types";
+export { QUESTION_TYPES, QUESTIONS, STATUSES, WS_MESSAGES } from "./types";

package/src/octto/session/server.ts

@@ -0,0 +1,89 @@
+// src/octto/session/server.ts
+import type { Server, ServerWebSocket } from "bun";
+
+import { config } from "../../utils/config";
+import { getHtmlBundle } from "../ui";
+import type { SessionStore } from "./sessions";
+import type { WsClientMessage } from "./types";
+
+interface WsData {
+  sessionId: string;
+}
+
+export async function createServer(
+  sessionId: string,
+  store: SessionStore,
+): Promise<{ server: Server<WsData>; port: number }> {
+  const htmlBundle = getHtmlBundle();
+
+  const server = Bun.serve<WsData>({
+    port: 0, // Random available port
+    hostname: config.octto.allowRemoteBind ? config.octto.bindAddress : "127.0.0.1",
+    fetch(req, server) {
+      const url = new URL(req.url);
+
+      // WebSocket upgrade
+      if (url.pathname === "/ws") {
+        const success = server.upgrade(req, {
+          data: { sessionId },
+        });
+        if (success) {
+          return undefined;
+        }
+        return new Response("WebSocket upgrade failed", { status: 400 });
+      }
+
+      // Serve the bundled HTML app
+      if (url.pathname === "/" || url.pathname === "/index.html") {
+        return new Response(htmlBundle, {
+          headers: {
+            "Content-Type": "text/html; charset=utf-8",
+          },
+        });
+      }
+
+      return new Response("Not Found", { status: 404 });
+    },
+    websocket: {
+      open(ws: ServerWebSocket<WsData>) {
+        const { sessionId } = ws.data;
+        store.handleWsConnect(sessionId, ws);
+      },
+      close(ws: ServerWebSocket<WsData>) {
+        const { sessionId } = ws.data;
+        store.handleWsDisconnect(sessionId);
+      },
+      message(ws: ServerWebSocket<WsData>, message: string | Buffer) {
+        const { sessionId } = ws.data;
+
+        let parsed: WsClientMessage;
+        try {
+          parsed = JSON.parse(message.toString()) as WsClientMessage;
+        } catch (error) {
+          console.error("[octto] Failed to parse WebSocket message:", error);
+          ws.send(
+            JSON.stringify({
+              type: "error",
+              error: "Invalid message format",
+              details: error instanceof Error ? error.message : "Parse failed",
+            }),
+          );
+          return;
+        }
+
+        store.handleWsMessage(sessionId, parsed);
+      },
+    },
+  });
+
+  // Port is always defined when using port: 0
+  const port = server.port;
+  if (port === undefined) {
+    throw new Error("Failed to get server port");
+  }
+
+  return {
+    server,
+    port,
+  };
+}