goatcode-sh 0.0.1 → 0.1.3

package/src/tools/session-manager/session-formatter.ts

@@ -0,0 +1,315 @@
+import type { Message, Part, Todo } from "@opencode-ai/sdk";
+import type { SessionSummary, SearchMatch, SessionDetail } from "./types";
+
+type TextPart = Part & { type: "text"; text: string };
+type ReasoningPart = Part & { type: "reasoning"; text: string };
+type ThinkingPart = Part & { type: "thinking"; thinking?: string; text?: string };
+type ToolPart = Part & {
+  type: "tool";
+  tool: string;
+  state: { status: string; input?: Record<string, unknown> };
+};
+
+function isTextPart(part: Part): part is TextPart {
+  return part.type === "text" && typeof (part as { text?: unknown }).text === "string";
+}
+
+function isReasoningPart(part: Part): part is ReasoningPart {
+  return part.type === "reasoning" && typeof (part as { text?: unknown }).text === "string";
+}
+
+function isThinkingPart(part: Part): part is ThinkingPart {
+  const type = (part as { type?: unknown }).type;
+  if (type !== "thinking") return false;
+  const thinking = (part as { thinking?: unknown }).thinking;
+  const text = (part as { text?: unknown }).text;
+  return typeof thinking === "string" || typeof text === "string";
+}
+
+function isToolPart(part: Part): part is ToolPart {
+  if (part.type !== "tool") {
+    return false;
+  }
+  const tool = (part as { tool?: unknown }).tool;
+  const state = (part as { state?: unknown }).state;
+  if (typeof tool !== "string") {
+    return false;
+  }
+  if (typeof state !== "object" || state === null || Array.isArray(state)) {
+    return false;
+  }
+  const status = (state as { status?: unknown }).status;
+  if (typeof status !== "string") {
+    return false;
+  }
+  const input = (state as { input?: unknown }).input;
+  return (
+    input === undefined || (typeof input === "object" && input !== null && !Array.isArray(input))
+  );
+}
+
+function formatDate(timestamp: number): string {
+  return new Date(timestamp).toISOString().split("T")[0];
+}
+
+function formatTimestamp(timestamp: number): string {
+  return new Date(timestamp).toISOString();
+}
+
+function safeTruncateJson(value: Record<string, unknown>, max = 100): string {
+  try {
+    return JSON.stringify(value).substring(0, max);
+  } catch {
+    return "[unserializable tool input]";
+  }
+}
+
+function computeDurationLabel(firstMs: number, lastMs: number): string | null {
+  const diff = lastMs - firstMs;
+  if (diff <= 0) return null;
+  const days = Math.floor(diff / (1000 * 60 * 60 * 24));
+  const hours = Math.floor((diff % (1000 * 60 * 60 * 24)) / (1000 * 60 * 60));
+  const parts: string[] = [];
+  if (days > 0) parts.push(`${days} day${days !== 1 ? "s" : ""}`);
+  if (hours > 0) parts.push(`${hours} hour${hours !== 1 ? "s" : ""}`);
+  return parts.length > 0 ? parts.join(", ") : null;
+}
+
+export function extractTextFromParts(parts: Part[]): string {
+  return parts
+    .filter(isTextPart)
+    .map((p) => p.text)
+    .join(" ")
+    .trim();
+}
+
+export function extractAgentsFromMessages(
+  messages: Array<{ info: Message; parts: Part[] }>,
+): string[] {
+  const agents = new Set<string>();
+  for (const { info } of messages) {
+    if (info.role === "user" && "agent" in info && info.agent) {
+      agents.add(info.agent);
+    }
+  }
+  return Array.from(agents);
+}
+
+export function buildSessionSummary(
+  id: string,
+  messages: Array<{ info: Message; parts: Part[] }>,
+): SessionSummary {
+  const timestamps = messages
+    .map((m) => m.info.time.created)
+    .filter((t): t is number => typeof t === "number");
+
+  const firstDate = timestamps.length > 0 ? formatDate(Math.min(...timestamps)) : null;
+  const lastDate = timestamps.length > 0 ? formatDate(Math.max(...timestamps)) : null;
+  const agentsUsed = extractAgentsFromMessages(messages);
+
+  return {
+    id,
+    messageCount: messages.length,
+    firstDate,
+    lastDate,
+    agentsUsed,
+  };
+}
+
+export function formatSessionList(summaries: SessionSummary[]): string {
+  if (summaries.length === 0) {
+    return "No sessions found.";
+  }
+
+  const headers = ["Session ID", "Messages", "First", "Last", "Agents"];
+  const rows = summaries.map((s) => [
+    s.id,
+    s.messageCount.toString(),
+    s.firstDate ?? "N/A",
+    s.lastDate ?? "N/A",
+    s.agentsUsed.join(", ") || "none",
+  ]);
+
+  const colWidths = headers.map((h, i) => Math.max(h.length, ...rows.map((r) => r[i].length)));
+
+  const formatRow = (cells: string[]): string =>
+    "| " + cells.map((cell, i) => cell.padEnd(colWidths[i])).join(" | ") + " |";
+
+  const separator = "|" + colWidths.map((w) => "-".repeat(w + 2)).join("|") + "|";
+
+  return [formatRow(headers), separator, ...rows.map(formatRow)].join("\n");
+}
+
+export function formatMessages(
+  sessionId: string,
+  messages: Array<{ info: Message; parts: Part[] }>,
+  options: { includeTodos?: boolean; todos?: Todo[] } = {},
+): string {
+  if (messages.length === 0) {
+    return "No messages found in this session.";
+  }
+
+  const lines: string[] = [`Session: ${sessionId}`, `Messages: ${messages.length}`];
+
+  for (const { info, parts } of messages) {
+    const ts = formatTimestamp(info.time.created);
+    const agent = info.role === "user" && "agent" in info && info.agent ? ` (${info.agent})` : "";
+    lines.push(`\n[Message ${info.id}] ${info.role}${agent} (${ts})`);
+
+    for (const part of parts) {
+      if (isTextPart(part)) {
+        const text = part.text.trim();
+        if (text) lines.push(text);
+      } else if (isReasoningPart(part) || isThinkingPart(part)) {
+        const text =
+          (part as { thinking?: string; text?: string }).thinking ??
+          (part as { text?: string }).text ??
+          "";
+        lines.push(`[thinking] ${text.substring(0, 200)}...`);
+      } else if (isToolPart(part)) {
+        const tp = part;
+        const inputStr = tp.state.input ? safeTruncateJson(tp.state.input, 100) : "";
+        lines.push(`[tool: ${tp.tool}] ${inputStr}`);
+      }
+    }
+  }
+
+  if (options.includeTodos && options.todos && options.todos.length > 0) {
+    lines.push("\n\n=== Todos ===");
+    for (const todo of options.todos) {
+      const mark =
+        todo.status === "completed" ? "[x]" : todo.status === "in_progress" ? "[-]" : "[ ]";
+      lines.push(`${mark} [${todo.status}] ${todo.content}`);
+    }
+  }
+
+  return lines.join("\n");
+}
+
+export function formatSearchResults(matches: SearchMatch[]): string {
+  if (matches.length === 0) {
+    return "No matches found.";
+  }
+
+  const lines: string[] = [
+    `Found ${matches.length} match${matches.length !== 1 ? "es" : ""} across sessions:\n`,
+  ];
+
+  for (const match of matches) {
+    const ts = match.timestamp ? ` ${match.timestamp}` : "";
+    lines.push(`[${match.sessionId}] Message ${match.messageId} (${match.role})${ts}`);
+    lines.push(`  ...${match.excerpt}...`);
+    lines.push(`  Matches: ${match.matchCount}\n`);
+  }
+
+  return lines.join("\n");
+}
+
+export function formatSessionDetail(detail: SessionDetail): string {
+  const lines: string[] = [
+    `Session ID: ${detail.id}`,
+    `Messages: ${detail.messageCount}`,
+    `Date Range: ${detail.firstDate ?? "N/A"} to ${detail.lastDate ?? "N/A"}`,
+  ];
+
+  if (detail.durationLabel) {
+    lines.push(`Duration: ${detail.durationLabel}`);
+  }
+
+  lines.push(`Agents Used: ${detail.agentsUsed.join(", ") || "none"}`);
+
+  if (detail.hasTodos) {
+    lines.push(
+      `Has Todos: Yes (${detail.todoCount} items, ${detail.completedTodoCount} completed)`,
+    );
+  } else {
+    lines.push("Has Todos: No");
+  }
+
+  lines.push(`Has Transcript: ${detail.hasTranscript ? "Yes" : "No"}`);
+
+  return lines.join("\n");
+}
+
+export function buildSessionDetail(
+  id: string,
+  messages: Array<{ info: Message; parts: Part[] }>,
+  todos: Todo[],
+  hasTranscript: boolean,
+): SessionDetail {
+  const timestamps = messages
+    .map((m) => m.info.time.created)
+    .filter((t): t is number => typeof t === "number");
+
+  const firstMs = timestamps.length > 0 ? Math.min(...timestamps) : null;
+  const lastMs = timestamps.length > 0 ? Math.max(...timestamps) : null;
+
+  const firstDate = firstMs !== null ? formatDate(firstMs) : null;
+  const lastDate = lastMs !== null ? formatDate(lastMs) : null;
+  const durationLabel =
+    firstMs !== null && lastMs !== null ? computeDurationLabel(firstMs, lastMs) : null;
+  const agentsUsed = extractAgentsFromMessages(messages);
+  const completedTodoCount = todos.filter((t) => t.status === "completed").length;
+
+  return {
+    id,
+    messageCount: messages.length,
+    firstDate,
+    lastDate,
+    durationLabel,
+    agentsUsed,
+    hasTodos: todos.length > 0,
+    todoCount: todos.length,
+    completedTodoCount,
+    hasTranscript,
+  };
+}
+
+export function searchMessages(
+  sessionId: string,
+  messages: Array<{ info: Message; parts: Part[] }>,
+  query: string,
+  caseSensitive: boolean,
+  maxResults: number,
+): SearchMatch[] {
+  const results: SearchMatch[] = [];
+  if (query.trim() === "" || maxResults <= 0) return results;
+  const searchQuery = caseSensitive ? query : query.toLowerCase();
+
+  for (const { info, parts } of messages) {
+    if (results.length >= maxResults) break;
+
+    let matchCount = 0;
+    let firstExcerpt = "";
+
+    for (const part of parts) {
+      if (!isTextPart(part)) continue;
+      const rawText = part.text;
+      const text = caseSensitive ? rawText : rawText.toLowerCase();
+      const occurrences = text.split(searchQuery).length - 1;
+      if (occurrences === 0) continue;
+
+      matchCount += occurrences;
+
+      if (!firstExcerpt) {
+        const idx = text.indexOf(searchQuery);
+        const start = Math.max(0, idx - 50);
+        const end = Math.min(rawText.length, idx + searchQuery.length + 50);
+        firstExcerpt = rawText.substring(start, end);
+      }
+    }
+
+    if (matchCount > 0) {
+      results.push({
+        sessionId,
+        messageId: info.id,
+        role: info.role,
+        excerpt: firstExcerpt,
+        matchCount,
+        timestamp: formatTimestamp(info.time.created),
+      });
+    }
+  }
+
+  return results;
+}

package/src/tools/session-manager/session-manager.test.ts

@@ -0,0 +1,254 @@
+import { describe, it, expect } from "bun:test";
+import type { OpenCodeContext } from "../../types/plugin";
+import { handleSessionList } from "./list/handler";
+import { handleSessionRead } from "./read/handler";
+import { handleSessionSearch } from "./search/handler";
+import { handleSessionInfo } from "./info/handler";
+
+const SESSION_A_ID = "ses_aaa111";
+const SESSION_B_ID = "ses_bbb222";
+
+const NOW = 1735000000000;
+const EARLIER = NOW - 86400000;
+
+const mockMessages = {
+  [SESSION_A_ID]: [
+    {
+      info: {
+        id: "msg_001",
+        sessionID: SESSION_A_ID,
+        role: "user" as const,
+        time: { created: EARLIER },
+        agent: "orchestrator",
+        model: { providerID: "anthropic", modelID: "claude-opus" },
+      },
+      parts: [
+        {
+          id: "part_001",
+          sessionID: SESSION_A_ID,
+          messageID: "msg_001",
+          type: "text" as const,
+          text: "Hello, can you help me implement the session manager tool?",
+        },
+      ],
+    },
+    {
+      info: {
+        id: "msg_002",
+        sessionID: SESSION_A_ID,
+        role: "assistant" as const,
+        time: { created: NOW },
+        parentID: "msg_001",
+        modelID: "claude-opus",
+        providerID: "anthropic",
+        mode: "auto",
+        path: { cwd: "/tmp", root: "/tmp" },
+        cost: 0,
+        tokens: { input: 100, output: 200, reasoning: 0, cache: { read: 0, write: 0 } },
+      },
+      parts: [
+        {
+          id: "part_002",
+          sessionID: SESSION_A_ID,
+          messageID: "msg_002",
+          type: "text" as const,
+          text: "Of course! Let me help you implement the session manager.",
+        },
+      ],
+    },
+  ],
+  [SESSION_B_ID]: [
+    {
+      info: {
+        id: "msg_003",
+        sessionID: SESSION_B_ID,
+        role: "user" as const,
+        time: { created: NOW },
+        agent: "worker",
+        model: { providerID: "openai", modelID: "gpt-4" },
+      },
+      parts: [
+        {
+          id: "part_003",
+          sessionID: SESSION_B_ID,
+          messageID: "msg_003",
+          type: "text" as const,
+          text: "Search for the session manager implementation.",
+        },
+      ],
+    },
+  ],
+};
+
+const mockSessions = [
+  {
+    id: SESSION_A_ID,
+    projectID: "proj_001",
+    directory: "/tmp/test-project",
+    title: "Session A",
+    version: "1.0",
+    time: { created: EARLIER, updated: NOW },
+  },
+  {
+    id: SESSION_B_ID,
+    projectID: "proj_001",
+    directory: "/tmp/test-project",
+    title: "Session B",
+    version: "1.0",
+    time: { created: NOW, updated: NOW },
+  },
+];
+
+const mockTodos = [
+  { id: "todo_001", content: "Implement session list", status: "completed", priority: "high" },
+  { id: "todo_002", content: "Write tests", status: "in_progress", priority: "medium" },
+];
+
+function createMockCtx(overrides: Record<string, unknown> = {}): OpenCodeContext {
+  return {
+    directory: "/tmp/test-project",
+    client: {
+      session: {
+        list: async () => ({ data: mockSessions }),
+        messages: async (opts: { path: { id: string } }) => {
+          const data = mockMessages[opts.path.id as keyof typeof mockMessages];
+          if (!data) return { data: undefined, error: "session not found" };
+          return { data };
+        },
+        todo: async () => ({ data: mockTodos }),
+      },
+    },
+    ...overrides,
+  } as unknown as OpenCodeContext;
+}
+
+describe("session_list", () => {
+  describe("#given two sessions exist", () => {
+    describe("#when called with no filters", () => {
+      it("#then returns a formatted table with both sessions", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionList({}, ctx);
+
+        expect(result).toContain("Session ID");
+        expect(result).toContain("Messages");
+        expect(result).toContain(SESSION_A_ID);
+        expect(result).toContain(SESSION_B_ID);
+      });
+    });
+
+    describe("#when called with limit=1", () => {
+      it("#then returns only one session", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionList({ limit: 1 }, ctx);
+
+        expect(result).toContain("Session ID");
+        const lines = result
+          .split("\n")
+          .filter((l) => l.startsWith("|") && !l.startsWith("| Session"));
+        expect(lines.length).toBe(2);
+      });
+    });
+  });
+});
+
+describe("session_read", () => {
+  describe("#given session A exists with 2 messages", () => {
+    describe("#when called with session_id=SESSION_A_ID", () => {
+      it("#then returns formatted messages with role and timestamp", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionRead({ session_id: SESSION_A_ID }, ctx);
+
+        expect(result).toContain(SESSION_A_ID);
+        expect(result).toContain("Messages: 2");
+        expect(result).toContain("user");
+        expect(result).toContain("assistant");
+        expect(result).toContain("Hello, can you help me implement the session manager tool?");
+      });
+    });
+
+    describe("#when called with include_todos=true", () => {
+      it("#then includes the todo list in output", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionRead(
+          { session_id: SESSION_A_ID, include_todos: true },
+          ctx,
+        );
+
+        expect(result).toContain("=== Todos ===");
+        expect(result).toContain("Implement session list");
+        expect(result).toContain("Write tests");
+      });
+    });
+
+    describe("#when called with a non-existent session_id", () => {
+      it("#then returns a not found message", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionRead({ session_id: "ses_nonexistent" }, ctx);
+
+        expect(result).toContain("Session not found");
+      });
+    });
+  });
+});
+
+describe("session_search", () => {
+  describe("#given two sessions with text content", () => {
+    describe("#when searching for a term that exists in session A", () => {
+      it("#then returns matching excerpts", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionSearch({ query: "session manager" }, ctx);
+
+        expect(result).toContain("Found");
+        expect(result).toContain(SESSION_A_ID);
+      });
+    });
+
+    describe("#when searching within a specific session", () => {
+      it("#then only searches that session", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionSearch(
+          { query: "session manager", session_id: SESSION_A_ID },
+          ctx,
+        );
+
+        expect(result).toContain(SESSION_A_ID);
+        expect(result).not.toContain(SESSION_B_ID);
+      });
+    });
+
+    describe("#when searching for a term that does not exist", () => {
+      it("#then returns no matches found", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionSearch({ query: "xyzzy_nonexistent_term_12345" }, ctx);
+
+        expect(result).toBe("No matches found.");
+      });
+    });
+  });
+});
+
+describe("session_info", () => {
+  describe("#given session A exists", () => {
+    describe("#when called with session_id=SESSION_A_ID", () => {
+      it("#then returns detailed session metadata", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionInfo({ session_id: SESSION_A_ID }, ctx);
+
+        expect(result).toContain(`Session ID: ${SESSION_A_ID}`);
+        expect(result).toContain("Messages: 2");
+        expect(result).toContain("Agents Used:");
+        expect(result).toContain("orchestrator");
+        expect(result).toContain("Has Todos: Yes");
+      });
+    });
+
+    describe("#when called with a non-existent session_id", () => {
+      it("#then returns a not found message", async () => {
+        const ctx = createMockCtx();
+        const result = await handleSessionInfo({ session_id: "ses_nonexistent" }, ctx);
+
+        expect(result).toContain("Session not found");
+      });
+    });
+  });
+});

package/src/tools/session-manager/types.ts

@@ -0,0 +1,41 @@
+import type { Session, Message, Part, Todo } from "@opencode-ai/sdk";
+
+export type { Session, Message, Part, Todo };
+
+export interface SessionSummary {
+  id: string;
+  messageCount: number;
+  firstDate: string | null;
+  lastDate: string | null;
+  agentsUsed: string[];
+}
+
+export interface MessageSummary {
+  id: string;
+  role: string;
+  agent: string | undefined;
+  timestamp: string;
+  textContent: string;
+}
+
+export interface SearchMatch {
+  sessionId: string;
+  messageId: string;
+  role: string;
+  excerpt: string;
+  matchCount: number;
+  timestamp: string | null;
+}
+
+export interface SessionDetail {
+  id: string;
+  messageCount: number;
+  firstDate: string | null;
+  lastDate: string | null;
+  durationLabel: string | null;
+  agentsUsed: string[];
+  hasTodos: boolean;
+  todoCount: number;
+  completedTodoCount: number;
+  hasTranscript: boolean;
+}

package/src/tools/shared/constants.ts

@@ -0,0 +1,3 @@
+export const TOOL_EXECUTION_TIMEOUT_MS = 30_000;
+export const TOOL_OUTPUT_MAX_CHARS = 100_000;
+export const TOOL_DESCRIPTION_MAX_CHARS = 1_024;

package/src/tools/skill/handler.test.ts

@@ -0,0 +1,57 @@
+import { describe, it, expect, beforeEach } from "bun:test";
+import { executeSkill, registerSkillLoader } from "./handler";
+
+describe("executeSkill", () => {
+  describe("#given a skill loader that returns content for known skills", () => {
+    beforeEach(() => {
+      registerSkillLoader({
+        load: (name: string, userMessage?: string) => {
+          if (name === "git-master") return "Git workflow instructions";
+          if (name === "with-msg" && userMessage) return `Context: ${userMessage}`;
+          return undefined;
+        },
+        list: () => [
+          { name: "git-master", description: "Git workflow" },
+          { name: "with-msg", description: "Uses the forwarded user message" },
+        ],
+      });
+    });
+
+    describe("#when called with a known skill name", () => {
+      it("#then returns the skill content from the loader", () => {
+        const result = executeSkill({ name: "git-master" });
+        expect(result).toBe("Git workflow instructions");
+      });
+    });
+
+    describe("#when called with an unknown skill name", () => {
+      it("#then returns a not-found message containing the skill name", () => {
+        const result = executeSkill({ name: "nonexistent-skill" });
+        expect(result).toContain("nonexistent-skill");
+        expect(result).toContain("not found");
+      });
+    });
+
+    describe("#when called with a user_message argument", () => {
+      it("#then forwards user_message to the loader", () => {
+        const result = executeSkill({ name: "with-msg", user_message: "patch release" });
+        expect(result).toBe("Context: patch release");
+      });
+    });
+  });
+
+  describe("#given a loader that always returns undefined", () => {
+    beforeEach(() => {
+      registerSkillLoader({ load: () => undefined, list: () => [] });
+    });
+
+    describe("#when executeSkill is called", () => {
+      it("#then returns the not-found message with available sources", () => {
+        const result = executeSkill({ name: "missing" });
+        expect(result).toContain("missing");
+        expect(result).toContain("not found");
+        expect(result).toContain(".opencode/skills");
+      });
+    });
+  });
+});

package/src/tools/skill/handler.ts

@@ -0,0 +1,27 @@
+import { log } from "../../shared/logger";
+import type { SkillArgs, SkillInfo, SkillLoader } from "./types";
+
+let registeredLoader: SkillLoader | null = null;
+
+export function registerSkillLoader(loader: SkillLoader): void {
+  registeredLoader = loader;
+}
+
+export function getAvailableSkills(): SkillInfo[] {
+  return typeof registeredLoader?.list === "function" ? registeredLoader.list() : [];
+}
+
+export function executeSkill(args: SkillArgs): string {
+  log("skill.execute", { name: args.name });
+
+  if (registeredLoader) {
+    const content = registeredLoader.load(args.name, args.user_message);
+    if (content !== undefined) {
+      return content;
+    }
+  }
+
+  const available = getAvailableSkills();
+  const names = available.map((s) => s.name).join(", ");
+  return `Skill '${args.name}' not found. Available: ${names || "none"}. Add project skills in .opencode/skills/.`;
+}

package/src/tools/skill/index.ts

@@ -0,0 +1,3 @@
+export { skillPlugin } from "./plugin";
+export { registerSkillLoader, executeSkill } from "./handler";
+export type { SkillArgs, SkillLoader } from "./types";