@farhanic017/octocode 3.5.0

package/test/cli/tui/plugin-toggle.test.ts

@@ -0,0 +1,264 @@
+import { expect, spyOn, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { pathToFileURL } from "url"
+import { tmpdir } from "../../fixture/fixture"
+import { createTuiPluginApi } from "../../fixture/tui-plugin"
+import { createTuiResolvedConfig } from "../../fixture/tui-runtime"
+import { TuiConfig } from "../../../src/config/tui"
+
+const { TuiPluginRuntime } = await import("../../../src/plugin/tui/runtime")
+
+test("toggles plugin runtime state by exported id", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "toggle-plugin.ts")
+      const spec = pathToFileURL(file).href
+      const marker = path.join(dir, "toggle.txt")
+
+      await Bun.write(
+        file,
+        `export default {
+  id: "demo.toggle",
+  tui: async (api, options) => {
+    const text = await Bun.file(options.marker).text().catch(() => "")
+    await Bun.write(options.marker, text + "start\\n")
+    api.lifecycle.onDispose(async () => {
+      const next = await Bun.file(options.marker).text().catch(() => "")
+      await Bun.write(options.marker, next + "stop\\n")
+    })
+  },
+}
+`,
+      )
+
+      return {
+        spec,
+        marker,
+      }
+    },
+  })
+
+  process.env.OCTOCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
+  const config = createTuiResolvedConfig({
+    plugin: [[tmp.extra.spec, { marker: tmp.extra.marker }]],
+    plugin_enabled: {
+      "demo.toggle": false,
+    },
+    plugin_origins: [
+      {
+        spec: [tmp.extra.spec, { marker: tmp.extra.marker }],
+        scope: "local",
+        source: path.join(tmp.path, "tui.json"),
+      },
+    ],
+  })
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+  const api = createTuiPluginApi()
+
+  try {
+    await TuiPluginRuntime.init({ api, config })
+
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).rejects.toThrow()
+    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.toggle")).toEqual({
+      id: "demo.toggle",
+      source: "file",
+      spec: tmp.extra.spec,
+      target: tmp.extra.spec,
+      enabled: false,
+      active: false,
+    })
+
+    await expect(TuiPluginRuntime.activatePlugin("demo.toggle")).resolves.toBe(true)
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("start\n")
+    expect(api.kv.get("plugin_enabled", {})).toEqual({
+      "demo.toggle": true,
+    })
+
+    await expect(TuiPluginRuntime.deactivatePlugin("demo.toggle")).resolves.toBe(true)
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("start\nstop\n")
+    expect(api.kv.get("plugin_enabled", {})).toEqual({
+      "demo.toggle": false,
+    })
+
+    await expect(TuiPluginRuntime.activatePlugin("missing.id")).resolves.toBe(false)
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+    delete process.env.OCTOCODE_PLUGIN_META_FILE
+  }
+})
+
+test("deactivating plugin pops pushed mode", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "mode-plugin.ts")
+      const spec = pathToFileURL(file).href
+
+      await Bun.write(
+        file,
+        `export default {
+  id: "demo.mode",
+  tui: async (api) => {
+    api.mode.push("demo.mode")
+  },
+}
+`,
+      )
+
+      return { spec }
+    },
+  })
+
+  const stack: { id: symbol; mode: string }[] = []
+  let popCount = 0
+  const api = createTuiPluginApi({
+    mode: {
+      current: () => stack.at(-1)?.mode ?? "base",
+      push(mode) {
+        const id = Symbol(mode)
+        let active = true
+        stack.push({ id, mode })
+        return () => {
+          if (!active) return
+          active = false
+          popCount += 1
+          const index = stack.findIndex((item) => item.id === id)
+          if (index !== -1) stack.splice(index, 1)
+        }
+      },
+    },
+  })
+  const config = createTuiResolvedConfig({
+    plugin: [tmp.extra.spec],
+    plugin_origins: [{ spec: tmp.extra.spec, scope: "local", source: path.join(tmp.path, "tui.json") }],
+  })
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+
+  try {
+    await TuiPluginRuntime.init({ api, config })
+
+    expect(api.mode.current()).toBe("demo.mode")
+    expect(popCount).toBe(0)
+
+    await expect(TuiPluginRuntime.deactivatePlugin("demo.mode")).resolves.toBe(true)
+
+    expect(api.mode.current()).toBe("base")
+    expect(popCount).toBe(1)
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+  }
+})
+
+test("kv plugin_enabled overrides tui config on startup", async () => {
+  await using tmp = await tmpdir({
+    init: async (dir) => {
+      const file = path.join(dir, "startup-plugin.ts")
+      const spec = pathToFileURL(file).href
+      const marker = path.join(dir, "startup.txt")
+
+      await Bun.write(
+        file,
+        `export default {
+  id: "demo.startup",
+  tui: async (_api, options) => {
+    await Bun.write(options.marker, "on")
+  },
+}
+`,
+      )
+
+      return {
+        spec,
+        marker,
+      }
+    },
+  })
+
+  process.env.OCTOCODE_PLUGIN_META_FILE = path.join(tmp.path, "plugin-meta.json")
+  const config = createTuiResolvedConfig({
+    plugin: [[tmp.extra.spec, { marker: tmp.extra.marker }]],
+    plugin_enabled: {
+      "demo.startup": false,
+    },
+    plugin_origins: [
+      {
+        spec: [tmp.extra.spec, { marker: tmp.extra.marker }],
+        scope: "local",
+        source: path.join(tmp.path, "tui.json"),
+      },
+    ],
+  })
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+  const api = createTuiPluginApi()
+  api.kv.set("plugin_enabled", {
+    "demo.startup": true,
+  })
+
+  try {
+    await TuiPluginRuntime.init({ api, config })
+
+    await expect(fs.readFile(tmp.extra.marker, "utf8")).resolves.toBe("on")
+    expect(TuiPluginRuntime.list().find((item) => item.id === "demo.startup")).toEqual({
+      id: "demo.startup",
+      source: "file",
+      spec: tmp.extra.spec,
+      target: tmp.extra.spec,
+      enabled: true,
+      active: true,
+    })
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+    delete process.env.OCTOCODE_PLUGIN_META_FILE
+  }
+})
+
+test("loads disabled-by-default internal plugin inactive and activates on demand", async () => {
+  await using tmp = await tmpdir()
+  const config = createTuiResolvedConfig()
+  const wait = spyOn(TuiConfig, "waitForDependencies").mockResolvedValue()
+  const cwd = spyOn(process, "cwd").mockImplementation(() => tmp.path)
+  const api = createTuiPluginApi()
+
+  try {
+    await TuiPluginRuntime.init({ api, config })
+
+    expect(TuiPluginRuntime.list().find((item) => item.id === "internal:plugin-manager")).toMatchObject({
+      enabled: true,
+      active: true,
+    })
+    expect(TuiPluginRuntime.list().find((item) => item.id === "which-key")).toEqual({
+      id: "which-key",
+      source: "internal",
+      spec: "which-key",
+      target: "which-key",
+      enabled: false,
+      active: false,
+    })
+
+    await expect(TuiPluginRuntime.activatePlugin("which-key")).resolves.toBe(true)
+    expect(TuiPluginRuntime.list().find((item) => item.id === "which-key")).toEqual({
+      id: "which-key",
+      source: "internal",
+      spec: "which-key",
+      target: "which-key",
+      enabled: true,
+      active: true,
+    })
+    expect(api.kv.get("plugin_enabled", {})).toEqual({
+      "which-key": true,
+    })
+  } finally {
+    await TuiPluginRuntime.dispose()
+    cwd.mockRestore()
+    wait.mockRestore()
+  }
+})

package/test/cli/tui/thread.test.ts

@@ -0,0 +1,36 @@
+import { describe, expect, test } from "bun:test"
+import fs from "fs/promises"
+import path from "path"
+import { tmpdir } from "../../fixture/fixture"
+import { resolveThreadDirectory } from "../../../src/cli/cmd/tui"
+
+describe("tui thread", () => {
+  test("loads the TUI integration lazily", async () => {
+    const source = await Bun.file(new URL("../../../src/cli/cmd/tui.ts", import.meta.url)).text()
+
+    expect(source).toContain('await import("../tui/layer")')
+    expect(source).toMatch(/await import\(["']@\/plugin\/tui\/runtime["']\)/)
+    expect(source).not.toContain('import("./app")')
+  })
+
+  async function check(project?: string) {
+    await using tmp = await tmpdir({ git: true })
+    const link = path.join(path.dirname(tmp.path), path.basename(tmp.path) + "-link")
+    const type = process.platform === "win32" ? "junction" : "dir"
+
+    try {
+      await fs.symlink(tmp.path, link, type)
+      expect(resolveThreadDirectory(project, link, tmp.path)).toBe(tmp.path)
+    } finally {
+      await fs.rm(link, { recursive: true, force: true }).catch(() => undefined)
+    }
+  }
+
+  test("uses the real cwd when PWD points at a symlink", async () => {
+    await check()
+  })
+
+  test("uses the real cwd after resolving a relative project from PWD", async () => {
+    await check(".")
+  })
+})

package/test/cli.test.ts

@@ -0,0 +1,7 @@
+import { test, expect } from "bun:test"
+import { spawnSync } from "child_process"
+
+test("octo binary runs without error", () => {
+  const result = spawnSync("bun", ["run", "./bin/octocode", "--help"], { encoding: "utf8" })
+  expect(result.status).toBe(0)
+})

package/test/command/acp-slash-detect.test.ts

@@ -0,0 +1,202 @@
+import { describe, expect, test } from "bun:test"
+
+// Replicate the ACP detectSlashCommand from acp/service.ts for testing
+type TextPart = { type: "text"; text: string }
+type ImagePart = { type: "image"; image: string }
+type Part = TextPart | ImagePart
+
+function detectSlashCommand(parts: Part[]) {
+  const text = parts
+    .filter((part): part is TextPart => part.type === "text")
+    .map((part) => part.text)
+    .join("")
+    .trim()
+  if (!text.startsWith("/")) return
+
+  const [name, ...rest] = text.slice(1).split(/\s+/)
+  if (!name) return
+  return { name, args: rest.join(" ").trim() }
+}
+
+function text(text: string): TextPart {
+  return { type: "text", text }
+}
+
+function image(url: string): ImagePart {
+  return { type: "image", image: url }
+}
+
+describe("ACP detectSlashCommand", () => {
+  test("returns undefined for non-slash text", () => {
+    expect(detectSlashCommand([text("hello")])).toBeUndefined()
+  })
+
+  test("returns undefined for empty parts", () => {
+    expect(detectSlashCommand([])).toBeUndefined()
+  })
+
+  test("returns undefined for empty text", () => {
+    expect(detectSlashCommand([text("")])).toBeUndefined()
+  })
+
+  test("returns undefined for whitespace only", () => {
+    expect(detectSlashCommand([text("   ")])).toBeUndefined()
+  })
+
+  test("returns undefined for slash with no command name", () => {
+    expect(detectSlashCommand([text("/")])).toBeUndefined()
+  })
+
+  test("parses simple command", () => {
+    expect(detectSlashCommand([text("/help")])).toEqual({ name: "help", args: "" })
+  })
+
+  test("parses command with arguments", () => {
+    expect(detectSlashCommand([text("/run tests")])).toEqual({ name: "run", args: "tests" })
+  })
+
+  test("parses command with multiple arguments", () => {
+    expect(detectSlashCommand([text("/debug fix the bug")])).toEqual({ name: "debug", args: "fix the bug" })
+  })
+
+  test("trims leading/trailing whitespace", () => {
+    expect(detectSlashCommand([text("  /help  ")])).toEqual({ name: "help", args: "" })
+  })
+
+  test("trims arguments", () => {
+    expect(detectSlashCommand([text("/run  tests  ")])).toEqual({ name: "run", args: "tests" })
+  })
+
+  test("handles multiple text parts joined", () => {
+    expect(detectSlashCommand([text("/help"), text(" me")])).toEqual({ name: "help", args: "me" })
+  })
+
+  test("handles text parts with no separator", () => {
+    // Text parts are joined without spaces, so "/help" + "me" = "/helpme"
+    expect(detectSlashCommand([text("/help"), text("me")])).toEqual({ name: "helpme", args: "" })
+  })
+
+  test("ignores image parts", () => {
+    expect(detectSlashCommand([image("https://example.com/img.png"), text("/help")])).toEqual({
+      name: "help",
+      args: "",
+    })
+  })
+
+  test("ignores image parts in middle", () => {
+    expect(detectSlashCommand([text("/run"), image("https://example.com/img.png"), text(" tests")])).toEqual({
+      name: "run",
+      args: "tests",
+    })
+  })
+
+  test("handles mixed parts with non-text", () => {
+    expect(
+      detectSlashCommand([text("/help"), { type: "other" } as any, text(" me")]),
+    ).toEqual({ name: "help", args: "me" })
+  })
+
+  test("returns undefined when joined text doesn't start with slash", () => {
+    expect(detectSlashCommand([text("hello"), text("/help")])).toBeUndefined()
+  })
+
+  test("returns undefined for just a slash", () => {
+    expect(detectSlashCommand([text("/")])).toBeUndefined()
+  })
+
+  test("returns undefined for slash followed by whitespace only", () => {
+    expect(detectSlashCommand([text("/   ")])).toBeUndefined()
+  })
+
+  test("handles tabs in arguments", () => {
+    expect(detectSlashCommand([text("/run\ttests")])).toEqual({ name: "run", args: "tests" })
+  })
+
+  test("handles newline in arguments", () => {
+    expect(detectSlashCommand([text("/help\nme")])).toEqual({ name: "help", args: "me" })
+  })
+
+  test("handles hyphenated command names", () => {
+    expect(detectSlashCommand([text("/code-review")])).toEqual({ name: "code-review", args: "" })
+  })
+
+  test("handles hyphenated command with arguments", () => {
+    expect(detectSlashCommand([text("/code-review please check")])).toEqual({
+      name: "code-review",
+      args: "please check",
+    })
+  })
+
+  test("handles all command names from terminal-ai-commands", () => {
+    const names = [
+      "btw",
+      "rewind",
+      "teleport",
+      "add-dir",
+      "sandbox",
+      "permissions",
+      "plugin",
+      "plugins",
+      "reload-plugins",
+      "ide",
+      "terminal-setup",
+      "remote-control",
+      "remote-env",
+      "chrome",
+      "install-github-app",
+      "fast",
+      "plan",
+      "todos",
+      "context",
+      "cost",
+      "usage",
+      "stats",
+      "insights",
+      "extra-usage",
+      "doctor",
+      "release-notes",
+      "upgrade",
+      "feedback",
+      "passes",
+      "stickers",
+      "mobile",
+      "ios",
+      "android",
+      "vim",
+      "color",
+      "statusline",
+      "output-style",
+      "voice",
+      "code-review",
+      "simplify",
+      "security-review",
+      "debug",
+      "loop",
+      "batch",
+      "claude-api",
+      "run",
+      "verify",
+      "run-skill-generator",
+      "hooks",
+      "start-work",
+      "ulw",
+      "refactor",
+      "dream",
+      "distill",
+      "goal",
+      "memory",
+    ]
+    for (const name of names) {
+      const result = detectSlashCommand([text(`/${name}`)])
+      expect(result).toEqual({ name, args: "" })
+    }
+  })
+
+  test("handles all command names with arguments", () => {
+    const names = ["help", "exit", "new", "run", "debug", "plan", "refactor", "code-review"]
+    for (const name of names) {
+      const result = detectSlashCommand([text(`/${name} some arguments here`)])
+      expect(result).toEqual({ name, args: "some arguments here" })
+    }
+  })
+})