jonsoc 1.1.48 → 1.1.50

package/test/cli/cmd/tui/fileref.test.ts

@@ -1,30 +0,0 @@
-import { describe, expect, test } from "bun:test"
-
-describe("File reference regex", () => {
-  test("matches file with line number", () => {
-    const regex = /([`'"<]?)([\w\-./]+\/[\w\-./]+(?:\.[\w]+)?)(?::(\d+))?/g
-    const text = "packages/jonsoc/src/cli/ui.ts:82"
-    const matches = [...text.matchAll(regex)]
-    expect(matches.length).toBeGreaterThan(0)
-    expect(matches[0][2]).toBe("packages/jonsoc/src/cli/ui.ts")
-    expect(matches[0][3]).toBe("82")
-  })
-
-  test("matches file without line number", () => {
-    const regex = /([`'"<]?)([\w\-./]+\/[\w\-./]+(?:\.[\w]+)?)(?::(\d+))?/g
-    const text = "packages/jonsoc/src/cli/ui.ts"
-    const matches = [...text.matchAll(regex)]
-    expect(matches.length).toBeGreaterThan(0)
-    expect(matches[0][2]).toBe("packages/jonsoc/src/cli/ui.ts")
-    expect(matches[0][3]).toBeUndefined()
-  })
-
-  test("matches file in text", () => {
-    const regex = /([`'"<]?)([\w\-./]+\/[\w\-./]+(?:\.[\w]+)?)(?::(\d+))?/g
-    const text = "Check packages/jonsoc/src/cli/ui.ts:82 for details"
-    const matches = [...text.matchAll(regex)]
-    expect(matches.length).toBe(1)
-    expect(matches[0][2]).toBe("packages/jonsoc/src/cli/ui.ts")
-    expect(matches[0][3]).toBe("82")
-  })
-})

package/test/cli/github-action.test.ts

@@ -1,129 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { extractResponseText } from "../../src/cli/cmd/github"
-import type { MessageV2 } from "../../src/session/message-v2"
-
-// Helper to create minimal valid parts
-function createTextPart(text: string): MessageV2.Part {
-  return {
-    id: "1",
-    sessionID: "s",
-    messageID: "m",
-    type: "text" as const,
-    text,
-  }
-}
-
-function createReasoningPart(text: string): MessageV2.Part {
-  return {
-    id: "1",
-    sessionID: "s",
-    messageID: "m",
-    type: "reasoning" as const,
-    text,
-    time: { start: 0 },
-  }
-}
-
-function createToolPart(tool: string, title: string, status: "completed" | "running" = "completed"): MessageV2.Part {
-  if (status === "completed") {
-    return {
-      id: "1",
-      sessionID: "s",
-      messageID: "m",
-      type: "tool" as const,
-      callID: "c1",
-      tool,
-      state: {
-        status: "completed",
-        input: {},
-        output: "",
-        title,
-        metadata: {},
-        time: { start: 0, end: 1 },
-      },
-    }
-  }
-  return {
-    id: "1",
-    sessionID: "s",
-    messageID: "m",
-    type: "tool" as const,
-    callID: "c1",
-    tool,
-    state: {
-      status: "running",
-      input: {},
-      time: { start: 0 },
-    },
-  }
-}
-
-function createStepStartPart(): MessageV2.Part {
-  return {
-    id: "1",
-    sessionID: "s",
-    messageID: "m",
-    type: "step-start" as const,
-  }
-}
-
-describe("extractResponseText", () => {
-  test("returns text from text part", () => {
-    const parts = [createTextPart("Hello world")]
-    expect(extractResponseText(parts)).toBe("Hello world")
-  })
-
-  test("returns last text part when multiple exist", () => {
-    const parts = [createTextPart("First"), createTextPart("Last")]
-    expect(extractResponseText(parts)).toBe("Last")
-  })
-
-  test("returns text even when tool parts follow", () => {
-    const parts = [createTextPart("I'll help with that."), createToolPart("todowrite", "3 todos")]
-    expect(extractResponseText(parts)).toBe("I'll help with that.")
-  })
-
-  test("returns null for reasoning-only response (signals summary needed)", () => {
-    const parts = [createReasoningPart("Let me think about this...")]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for tool-only response (signals summary needed)", () => {
-    // This is the exact scenario from the bug report - todowrite with no text
-    const parts = [createToolPart("todowrite", "8 todos")]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("returns null for multiple completed tools", () => {
-    const parts = [
-      createToolPart("read", "src/file.ts"),
-      createToolPart("edit", "src/file.ts"),
-      createToolPart("bash", "bun test"),
-    ]
-    expect(extractResponseText(parts)).toBeNull()
-  })
-
-  test("ignores running tool parts (throws since no completed tools)", () => {
-    const parts = [createToolPart("bash", "", "running")]
-    expect(() => extractResponseText(parts)).toThrow("Failed to parse response")
-  })
-
-  test("throws with part types on empty array", () => {
-    expect(() => extractResponseText([])).toThrow("Part types found: [none]")
-  })
-
-  test("throws with part types on unhandled parts", () => {
-    const parts = [createStepStartPart()]
-    expect(() => extractResponseText(parts)).toThrow("Part types found: [step-start]")
-  })
-
-  test("prefers text over reasoning when both present", () => {
-    const parts = [createReasoningPart("Internal thinking..."), createTextPart("Final answer")]
-    expect(extractResponseText(parts)).toBe("Final answer")
-  })
-
-  test("prefers text over tools when both present", () => {
-    const parts = [createToolPart("read", "src/file.ts"), createTextPart("Here's what I found")]
-    expect(extractResponseText(parts)).toBe("Here's what I found")
-  })
-})

package/test/cli/github-remote.test.ts

@@ -1,80 +0,0 @@
-import { test, expect } from "bun:test"
-import { parseGitHubRemote } from "../../src/cli/cmd/github"
-
-test("parses https URL with .git suffix", () => {
-  expect(parseGitHubRemote("https://github.com/sst/jonsoc.git")).toEqual({ owner: "sst", repo: "jonsoc" })
-})
-
-test("parses https URL without .git suffix", () => {
-  expect(parseGitHubRemote("https://github.com/sst/jonsoc")).toEqual({ owner: "sst", repo: "jonsoc" })
-})
-
-test("parses git@ URL with .git suffix", () => {
-  expect(parseGitHubRemote("git@github.com:sst/jonsoc.git")).toEqual({ owner: "sst", repo: "jonsoc" })
-})
-
-test("parses git@ URL without .git suffix", () => {
-  expect(parseGitHubRemote("git@github.com:sst/jonsoc")).toEqual({ owner: "sst", repo: "jonsoc" })
-})
-
-test("parses ssh:// URL with .git suffix", () => {
-  expect(parseGitHubRemote("ssh://git@github.com/sst/jonsoc.git")).toEqual({ owner: "sst", repo: "jonsoc" })
-})
-
-test("parses ssh:// URL without .git suffix", () => {
-  expect(parseGitHubRemote("ssh://git@github.com/sst/jonsoc")).toEqual({ owner: "sst", repo: "jonsoc" })
-})
-
-test("parses http URL", () => {
-  expect(parseGitHubRemote("http://github.com/owner/repo")).toEqual({ owner: "owner", repo: "repo" })
-})
-
-test("parses URL with hyphenated owner and repo names", () => {
-  expect(parseGitHubRemote("https://github.com/my-org/my-repo.git")).toEqual({ owner: "my-org", repo: "my-repo" })
-})
-
-test("parses URL with underscores in names", () => {
-  expect(parseGitHubRemote("git@github.com:my_org/my_repo.git")).toEqual({ owner: "my_org", repo: "my_repo" })
-})
-
-test("parses URL with numbers in names", () => {
-  expect(parseGitHubRemote("https://github.com/org123/repo456")).toEqual({ owner: "org123", repo: "repo456" })
-})
-
-test("parses repos with dots in the name", () => {
-  expect(parseGitHubRemote("https://github.com/socketio/socket.io.git")).toEqual({
-    owner: "socketio",
-    repo: "socket.io",
-  })
-  expect(parseGitHubRemote("https://github.com/vuejs/vue.js")).toEqual({
-    owner: "vuejs",
-    repo: "vue.js",
-  })
-  expect(parseGitHubRemote("git@github.com:mrdoob/three.js.git")).toEqual({
-    owner: "mrdoob",
-    repo: "three.js",
-  })
-  expect(parseGitHubRemote("https://github.com/jashkenas/backbone.git")).toEqual({
-    owner: "jashkenas",
-    repo: "backbone",
-  })
-})
-
-test("returns null for non-github URLs", () => {
-  expect(parseGitHubRemote("https://gitlab.com/owner/repo.git")).toBeNull()
-  expect(parseGitHubRemote("git@gitlab.com:owner/repo.git")).toBeNull()
-  expect(parseGitHubRemote("https://bitbucket.org/owner/repo")).toBeNull()
-})
-
-test("returns null for invalid URLs", () => {
-  expect(parseGitHubRemote("not-a-url")).toBeNull()
-  expect(parseGitHubRemote("")).toBeNull()
-  expect(parseGitHubRemote("github.com")).toBeNull()
-  expect(parseGitHubRemote("https://github.com/")).toBeNull()
-  expect(parseGitHubRemote("https://github.com/owner")).toBeNull()
-})
-
-test("returns null for URLs with extra path segments", () => {
-  expect(parseGitHubRemote("https://github.com/owner/repo/tree/main")).toBeNull()
-  expect(parseGitHubRemote("https://github.com/owner/repo/blob/main/file.ts")).toBeNull()
-})

package/test/cli/tui/navigator_logic.test.ts

@@ -1,99 +0,0 @@
-import { createSignal, createEffect, createRoot } from "solid-js";
-import { describe, expect, test, mock } from "bun:test";
-
-describe("Navigator Logic Reproduction", () => {
-    test("openFilePath should triggers loadFile exactly once via effect when path changes", async () => {
-        createRoot(async (dispose) => {
-            const [activePath, setActivePath] = createSignal<string | null>(null);
-            const [loaded, setLoaded] = createSignal(true);
-
-            // Mock loadFile
-            const loadFile = mock((file: string, force: boolean) => {
-                // console.log(`Loading ${file}, force=${force}`);
-            });
-
-            // The fixed logic from Navigator.tsx
-            const openFilePath = (nextPath: string) => {
-                const current = activePath();
-                if (current !== nextPath) {
-                    // Simulate setting loading flags activePath
-                    setActivePath(nextPath);
-                    // Explicit loadFile REMOVED here
-                } else if (loaded()) {
-                    loadFile(nextPath, true);
-                }
-            };
-
-            // The effect from Navigator.tsx (simplified)
-            createEffect(() => {
-                const file = activePath();
-                if (file) {
-                    // In real code this is untracked, but here simple call is fine
-                    loadFile(file, false);
-                }
-            });
-
-            // ACT 1: Open a new file
-            openFilePath("test.txt");
-
-            // Allow effects to flush
-            await new Promise(r => setTimeout(r, 10));
-
-            // ASSERT 1
-            expect(loadFile).toHaveBeenCalledTimes(1);
-            expect(loadFile).toHaveBeenCalledWith("test.txt", false);
-
-            // ACT 2: Open the SAME file again (force reload)
-            openFilePath("test.txt");
-            await new Promise(r => setTimeout(r, 10));
-
-            // ASSERT 2
-            // Should be called again with force=true via the imperative path
-            // Effect should NOT run because activePath didn't change
-            expect(loadFile).toHaveBeenCalledTimes(2);
-            expect(loadFile).toHaveBeenLastCalledWith("test.txt", true);
-
-            // ACT 3: Switch to another file
-            openFilePath("other.txt");
-            await new Promise(r => setTimeout(r, 10));
-
-            // ASSERT 3
-            expect(loadFile).toHaveBeenCalledTimes(3);
-            expect(loadFile).toHaveBeenLastCalledWith("other.txt", false);
-
-            dispose();
-        });
-    });
-
-    test("Legacy broken logic would double call", async () => {
-        createRoot(async (dispose) => {
-            const [activePath, setActivePath] = createSignal<string | null>(null);
-            const loadFile = mock((file: string, force: boolean) => { });
-
-            // The BROKEN logic
-            const openFilePath = (nextPath: string) => {
-                const current = activePath();
-                if (current !== nextPath) {
-                    setActivePath(nextPath);
-                    // BROKEN: Explicit loadFile called here
-                    loadFile(nextPath, false);
-                }
-            };
-
-            createEffect(() => {
-                const file = activePath();
-                if (file) {
-                    loadFile(file, false);
-                }
-            });
-
-            openFilePath("test.txt");
-            await new Promise(r => setTimeout(r, 10));
-
-            // This demonstrates the issue we fixed: it was called twice!
-            expect(loadFile).toHaveBeenCalledTimes(2);
-
-            dispose();
-        });
-    });
-});

package/test/cli/tui/transcript.test.ts

@@ -1,297 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import {
-  formatAssistantHeader,
-  formatMessage,
-  formatPart,
-  formatTranscript,
-} from "../../../src/cli/cmd/tui/util/transcript"
-import type { AssistantMessage, Part, UserMessage } from "@jonsoc/sdk/v2"
-
-describe("transcript", () => {
-  describe("formatAssistantHeader", () => {
-    const baseMsg: AssistantMessage = {
-      id: "msg_123",
-      sessionID: "ses_123",
-      role: "assistant",
-      agent: "build",
-      modelID: "claude-sonnet-4-20250514",
-      providerID: "anthropic",
-      mode: "",
-      parentID: "msg_parent",
-      path: { cwd: "/test", root: "/test" },
-      cost: 0.001,
-      tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-      time: { created: 1000000, completed: 1005400 },
-    }
-
-    test("includes metadata when enabled", () => {
-      const result = formatAssistantHeader(baseMsg, true)
-      expect(result).toBe("## Assistant (Build · claude-sonnet-4-20250514 · 5.4s)\n\n")
-    })
-
-    test("excludes metadata when disabled", () => {
-      const result = formatAssistantHeader(baseMsg, false)
-      expect(result).toBe("## Assistant\n\n")
-    })
-
-    test("handles missing completed time", () => {
-      const msg = { ...baseMsg, time: { created: 1000000 } }
-      const result = formatAssistantHeader(msg as AssistantMessage, true)
-      expect(result).toBe("## Assistant (Build · claude-sonnet-4-20250514)\n\n")
-    })
-
-    test("titlecases agent name", () => {
-      const msg = { ...baseMsg, agent: "plan" }
-      const result = formatAssistantHeader(msg, true)
-      expect(result).toContain("Plan")
-    })
-  })
-
-  describe("formatPart", () => {
-    const options = { thinking: true, toolDetails: true, assistantMetadata: true }
-
-    test("formats text part", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "text",
-        text: "Hello world",
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("Hello world\n\n")
-    })
-
-    test("skips synthetic text parts", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "text",
-        text: "Synthetic content",
-        synthetic: true,
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("")
-    })
-
-    test("formats reasoning when thinking enabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "reasoning",
-        text: "Let me think...",
-        time: { start: 1000 },
-      }
-      const result = formatPart(part, options)
-      expect(result).toBe("_Thinking:_\n\nLet me think...\n\n")
-    })
-
-    test("skips reasoning when thinking disabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "reasoning",
-        text: "Let me think...",
-        time: { start: 1000 },
-      }
-      const result = formatPart(part, { ...options, thinking: false })
-      expect(result).toBe("")
-    })
-
-    test("formats tool part with details", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "ls" },
-          output: "file1.txt\nfile2.txt",
-          title: "List files",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      expect(result).toContain("Tool: bash")
-      expect(result).toContain("**Input:**")
-      expect(result).toContain('"command": "ls"')
-      expect(result).toContain("**Output:**")
-      expect(result).toContain("file1.txt")
-    })
-
-    test("formats tool part without details when disabled", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "completed",
-          input: { command: "ls" },
-          output: "file1.txt",
-          title: "List files",
-          metadata: {},
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, { ...options, toolDetails: false })
-      expect(result).toContain("Tool: bash")
-      expect(result).not.toContain("**Input:**")
-      expect(result).not.toContain("**Output:**")
-    })
-
-    test("formats tool error", () => {
-      const part: Part = {
-        id: "part_1",
-        sessionID: "ses_123",
-        messageID: "msg_123",
-        type: "tool",
-        callID: "call_1",
-        tool: "bash",
-        state: {
-          status: "error",
-          input: { command: "invalid" },
-          error: "Command failed",
-          time: { start: 1000, end: 1100 },
-        },
-      }
-      const result = formatPart(part, options)
-      expect(result).toContain("**Error:**")
-      expect(result).toContain("Command failed")
-    })
-  })
-
-  describe("formatMessage", () => {
-    const options = { thinking: true, toolDetails: true, assistantMetadata: true }
-
-    test("formats user message", () => {
-      const msg: UserMessage = {
-        id: "msg_123",
-        sessionID: "ses_123",
-        role: "user",
-        agent: "build",
-        model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-        time: { created: 1000000 },
-      }
-      const parts: Part[] = [{ id: "p1", sessionID: "ses_123", messageID: "msg_123", type: "text", text: "Hello" }]
-      const result = formatMessage(msg, parts, options)
-      expect(result).toContain("## User")
-      expect(result).toContain("Hello")
-    })
-
-    test("formats assistant message with metadata", () => {
-      const msg: AssistantMessage = {
-        id: "msg_123",
-        sessionID: "ses_123",
-        role: "assistant",
-        agent: "build",
-        modelID: "claude-sonnet-4-20250514",
-        providerID: "anthropic",
-        mode: "",
-        parentID: "msg_parent",
-        path: { cwd: "/test", root: "/test" },
-        cost: 0.001,
-        tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-        time: { created: 1000000, completed: 1005400 },
-      }
-      const parts: Part[] = [{ id: "p1", sessionID: "ses_123", messageID: "msg_123", type: "text", text: "Hi there" }]
-      const result = formatMessage(msg, parts, options)
-      expect(result).toContain("## Assistant (Build · claude-sonnet-4-20250514 · 5.4s)")
-      expect(result).toContain("Hi there")
-    })
-  })
-
-  describe("formatTranscript", () => {
-    test("formats complete transcript", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "user" as const,
-            agent: "build",
-            model: { providerID: "anthropic", modelID: "claude-sonnet-4-20250514" },
-            time: { created: 1000000000000 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Hello" }],
-        },
-        {
-          info: {
-            id: "msg_2",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "build",
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_1",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p2", sessionID: "ses_abc123", messageID: "msg_2", type: "text" as const, text: "Hi!" }],
-        },
-      ]
-      const options = { thinking: false, toolDetails: false, assistantMetadata: true }
-
-      const result = formatTranscript(session, messages, options)
-
-      expect(result).toContain("# Test Session")
-      expect(result).toContain("**Session ID:** ses_abc123")
-      expect(result).toContain("## User")
-      expect(result).toContain("Hello")
-      expect(result).toContain("## Assistant (Build · claude-sonnet-4-20250514 · 0.5s)")
-      expect(result).toContain("Hi!")
-      expect(result).toContain("---")
-    })
-
-    test("formats transcript without assistant metadata", () => {
-      const session = {
-        id: "ses_abc123",
-        title: "Test Session",
-        time: { created: 1000000000000, updated: 1000000001000 },
-      }
-      const messages = [
-        {
-          info: {
-            id: "msg_1",
-            sessionID: "ses_abc123",
-            role: "assistant" as const,
-            agent: "build",
-            modelID: "claude-sonnet-4-20250514",
-            providerID: "anthropic",
-            mode: "",
-            parentID: "msg_0",
-            path: { cwd: "/test", root: "/test" },
-            cost: 0.001,
-            tokens: { input: 100, output: 50, reasoning: 0, cache: { read: 0, write: 0 } },
-            time: { created: 1000000000100, completed: 1000000000600 },
-          },
-          parts: [{ id: "p1", sessionID: "ses_abc123", messageID: "msg_1", type: "text" as const, text: "Response" }],
-        },
-      ]
-      const options = { thinking: false, toolDetails: false, assistantMetadata: false }
-
-      const result = formatTranscript(session, messages, options)
-
-      expect(result).toContain("## Assistant\n\n")
-      expect(result).not.toContain("Build")
-      expect(result).not.toContain("claude-sonnet-4-20250514")
-    })
-  })
-})