@farhanic017/octocode 3.5.0

package/test/command/demo-slash.test.ts

@@ -0,0 +1,213 @@
+import { describe, expect, test } from "bun:test"
+
+// Test the demo slash command recognition from demo.ts
+// The demo.ts handles /help, /permission, /question, /fmt
+
+describe("demo slash commands", () => {
+  describe("/help", () => {
+    test("is recognized as slash command", () => {
+      const cmd = "/help"
+      expect(cmd.startsWith("/")).toBe(true)
+      expect(cmd.split(/\s+/)[0]).toBe("/help")
+    })
+  })
+
+  describe("/permission", () => {
+    test("is recognized as slash command", () => {
+      const cmd = "/permission bash"
+      expect(cmd.startsWith("/")).toBe(true)
+      expect(cmd.split(/\s+/)[0]).toBe("/permission")
+    })
+
+    test("extracts permission kind", () => {
+      const cmd = "/permission bash"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBe("bash")
+    })
+
+    test("handles missing kind", () => {
+      const cmd = "/permission"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBeUndefined()
+    })
+  })
+
+  describe("/question", () => {
+    test("is recognized as slash command", () => {
+      const cmd = "/question custom"
+      expect(cmd.startsWith("/")).toBe(true)
+      expect(cmd.split(/\s+/)[0]).toBe("/question")
+    })
+
+    test("extracts question kind", () => {
+      const cmd = "/question custom"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBe("custom")
+    })
+
+    test("handles missing kind", () => {
+      const cmd = "/question"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBeUndefined()
+    })
+  })
+
+  describe("/fmt", () => {
+    test("is recognized as slash command", () => {
+      const cmd = "/fmt markdown"
+      expect(cmd.startsWith("/")).toBe(true)
+      expect(cmd.split(/\s+/)[0]).toBe("/fmt")
+    })
+
+    test("extracts format kind", () => {
+      const cmd = "/fmt markdown"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBe("markdown")
+    })
+
+    test("extracts format body", () => {
+      const cmd = "/fmt text your custom text"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBe("text")
+      expect(list.slice(2).join(" ")).toBe("your custom text")
+    })
+
+    test("handles missing kind", () => {
+      const cmd = "/fmt"
+      const list = cmd.split(/\s+/)
+      expect(list[1]).toBeUndefined()
+    })
+  })
+})
+
+describe("command text parsing patterns", () => {
+  test("all demo commands start with slash", () => {
+    const demoCommands = ["/help", "/permission bash", "/question custom", "/fmt markdown"]
+    for (const cmd of demoCommands) {
+      expect(cmd.startsWith("/")).toBe(true)
+    }
+  })
+
+  test("command name extraction works for all patterns", () => {
+    const commands = [
+      { input: "/help", expected: "/help" },
+      { input: "/permission bash", expected: "/permission" },
+      { input: "/question custom", expected: "/question" },
+      { input: "/fmt markdown", expected: "/fmt" },
+      { input: "/fmt text your custom text", expected: "/fmt" },
+    ]
+    for (const { input, expected } of commands) {
+      expect(input.split(/\s+/)[0]).toBe(expected)
+    }
+  })
+
+  test("argument extraction works", () => {
+    const commands = [
+      { input: "/help", args: "" },
+      { input: "/permission bash", args: "bash" },
+      { input: "/question custom", args: "custom" },
+      { input: "/fmt markdown", args: "markdown" },
+      { input: "/fmt text your custom text", args: "text your custom text" },
+    ]
+    for (const { input, args } of commands) {
+      const list = input.split(/\s+/)
+      expect(list.slice(1).join(" ")).toBe(args)
+    }
+  })
+})
+
+describe("terminal-ai command integration", () => {
+  test("all terminal-ai commands can be invoked with slash prefix", () => {
+    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 input = `/${name}`
+      expect(input.startsWith("/")).toBe(true)
+      expect(input.split(/\s+/)[0]).toBe(`/${name}`)
+    }
+  })
+
+  test("terminal-ai commands can have arguments", () => {
+    const commandsWithArgs = [
+      { input: "/btw what is this", name: "btw", args: "what is this" },
+      { input: "/rewind the last change", name: "rewind", args: "the last change" },
+      { input: "/teleport to slack", name: "teleport", args: "to slack" },
+      { input: "/fast fix the bug", name: "fast", args: "fix the bug" },
+      { input: "/plan the refactor", name: "plan", args: "the refactor" },
+      { input: "/debug this error", name: "debug", args: "this error" },
+      { input: "/run tests", name: "run", args: "tests" },
+      { input: "/verify the build", name: "verify", args: "the build" },
+      { input: "/code-review this PR", name: "code-review", args: "this PR" },
+      { input: "/security-review the auth module", name: "security-review", args: "the auth module" },
+      { input: "/simplify this code", name: "simplify", args: "this code" },
+      { input: "/refactor this function", name: "refactor", args: "this function" },
+      { input: "/goal all tests pass", name: "goal", args: "all tests pass" },
+      { input: "/ulw think deeply about this", name: "ulw", args: "think deeply about this" },
+      { input: "/batch edit files", name: "batch", args: "edit files" },
+      { input: "/loop fix and verify", name: "loop", args: "fix and verify" },
+      { input: "/doctor check environment", name: "doctor", args: "check environment" },
+      { input: "/cost estimate this task", name: "cost", args: "estimate this task" },
+    ]
+    for (const { input, name, args } of commandsWithArgs) {
+      const parts = input.split(/\s+/)
+      expect(parts[0]).toBe(`/${name}`)
+      expect(parts.slice(1).join(" ")).toBe(args)
+    }
+  })
+})

package/test/command/slash-head.test.ts

@@ -0,0 +1,232 @@
+import { describe, expect, test } from "bun:test"
+
+// Replicate the slashHead function from footer.prompt.tsx for testing
+function slashHead(text: string) {
+  if (!text.startsWith("/")) {
+    return
+  }
+
+  for (let i = 1; i < text.length; i++) {
+    switch (text[i]) {
+      case " ":
+      case "\t":
+      case "\n":
+        return { name: text.slice(1, i), arguments: text.slice(i + 1), end: i }
+    }
+  }
+
+  return { name: text.slice(1), arguments: "", end: text.length }
+}
+
+function slashQuery(text: string, cursor: number) {
+  const head = slashHead(text.slice(0, cursor))
+  if (!head || head.end !== cursor) {
+    return
+  }
+
+  return head.name
+}
+
+function parseSlashCommand(
+  text: string,
+  commands: Array<{ name: string; description?: string }> | undefined,
+) {
+  const head = slashHead(text)
+  if (!head || head.name.length === 0) {
+    return { type: "none" as const }
+  }
+
+  if (!commands) {
+    return { type: "pending" as const }
+  }
+
+  if (!commands.some((item) => item.name === head.name)) {
+    return { type: "none" as const }
+  }
+
+  return { type: "command" as const, command: { name: head.name, arguments: head.arguments } }
+}
+
+describe("slashHead parsing", () => {
+  test("returns undefined for non-slash text", () => {
+    expect(slashHead("hello")).toBeUndefined()
+    expect(slashHead("")).toBeUndefined()
+    expect(slashHead("test")).toBeUndefined()
+    expect(slashHead("!command")).toBeUndefined()
+  })
+
+  test("parses command name without arguments", () => {
+    const result = slashHead("/help")
+    expect(result).toEqual({ name: "help", arguments: "", end: 5 })
+  })
+
+  test("parses command name with arguments", () => {
+    const result = slashHead("/run tests")
+    expect(result).toEqual({ name: "run", arguments: "tests", end: 4 })
+  })
+
+  test("parses command name with multiple arguments", () => {
+    const result = slashHead("/debug fix the bug")
+    expect(result).toEqual({ name: "debug", arguments: "fix the bug", end: 6 })
+  })
+
+  test("handles tab separator", () => {
+    const result = slashHead("/help\tme")
+    expect(result).toEqual({ name: "help", arguments: "me", end: 5 })
+  })
+
+  test("handles newline separator", () => {
+    const result = slashHead("/help\nme")
+    expect(result).toEqual({ name: "help", arguments: "me", end: 5 })
+  })
+
+  test("handles empty arguments after space", () => {
+    const result = slashHead("/help ")
+    expect(result).toEqual({ name: "help", arguments: "", end: 5 })
+  })
+
+  test("handles single character command", () => {
+    const result = slashHead("/q")
+    expect(result).toEqual({ name: "q", arguments: "", end: 2 })
+  })
+
+  test("handles single slash only", () => {
+    const result = slashHead("/")
+    expect(result).toEqual({ name: "", arguments: "", end: 1 })
+  })
+
+  test("handles command with spaces in arguments", () => {
+    const result = slashHead("/plan refactor the code")
+    expect(result).toEqual({ name: "plan", arguments: "refactor the code", end: 5 })
+  })
+
+  test("handles very long command names", () => {
+    const result = slashHead("/run-skill-generator")
+    expect(result).toEqual({ name: "run-skill-generator", arguments: "", end: 20 })
+  })
+
+  test("handles command with hyphens", () => {
+    const result = slashHead("/code-review please")
+    expect(result).toEqual({ name: "code-review", arguments: "please", end: 12 })
+  })
+
+  test("handles command with numbers", () => {
+    const result = slashHead("/cmd123 arg")
+    expect(result).toEqual({ name: "cmd123", arguments: "arg", end: 7 })
+  })
+})
+
+describe("slashQuery parsing", () => {
+  test("returns name when cursor is at end of slash command", () => {
+    expect(slashQuery("/help", 5)).toBe("help")
+    expect(slashQuery("/run", 4)).toBe("run")
+    expect(slashQuery("/exit", 5)).toBe("exit")
+  })
+
+  test("returns partial name during typing", () => {
+    expect(slashQuery("/hel", 4)).toBe("hel")
+    expect(slashQuery("/ru", 3)).toBe("ru")
+    expect(slashQuery("/", 1)).toBe("")
+  })
+
+  test("returns name when cursor is at end of command name", () => {
+    // "/help me" sliced to cursor 5 = "/help", head.end=5, cursor=5 → match
+    expect(slashQuery("/help me", 5)).toBe("help")
+    // "/run tests" sliced to cursor 4 = "/run", head.end=4, cursor=4 → match
+    expect(slashQuery("/run tests", 4)).toBe("run")
+  })
+
+  test("returns undefined when cursor is past command name", () => {
+    // "/help me" sliced to cursor 7 = "/help ", head.end=5, cursor=7 → no match
+    expect(slashQuery("/help me", 7)).toBeUndefined()
+    // "/help me" sliced to cursor 8 = "/help m", head.end=5, cursor=8 → no match
+    expect(slashQuery("/help me", 8)).toBeUndefined()
+  })
+
+  test("returns undefined for non-slash text", () => {
+    expect(slashQuery("hello", 5)).toBeUndefined()
+    expect(slashQuery("", 0)).toBeUndefined()
+  })
+
+  test("returns undefined for empty text", () => {
+    expect(slashQuery("", 0)).toBeUndefined()
+  })
+
+  test("returns partial name when cursor is mid-command", () => {
+    // "/help" sliced to cursor 3 = "/he", head.end=3, cursor=3 → match
+    expect(slashQuery("/help", 3)).toBe("he")
+  })
+
+  test("returns empty name for just slash", () => {
+    expect(slashQuery("/", 1)).toBe("")
+  })
+})
+
+describe("parseSlashCommand", () => {
+  const commands = [
+    { name: "help", description: "Show help" },
+    { name: "exit", description: "Exit" },
+    { name: "run", description: "Run tests" },
+    { name: "debug", description: "Debug" },
+    { name: "code-review", description: "Review code" },
+  ]
+
+  test("returns none for empty text", () => {
+    expect(parseSlashCommand("", commands)).toEqual({ type: "none" })
+  })
+
+  test("returns none for non-slash text", () => {
+    expect(parseSlashCommand("hello", commands)).toEqual({ type: "none" })
+  })
+
+  test("returns none for slash with no command name", () => {
+    expect(parseSlashCommand("/", commands)).toEqual({ type: "none" })
+  })
+
+  test("returns none for unknown command", () => {
+    expect(parseSlashCommand("/unknown", commands)).toEqual({ type: "none" })
+  })
+
+  test("returns command for known command", () => {
+    expect(parseSlashCommand("/help", commands)).toEqual({
+      type: "command",
+      command: { name: "help", arguments: "" },
+    })
+  })
+
+  test("returns command with arguments", () => {
+    expect(parseSlashCommand("/run tests", commands)).toEqual({
+      type: "command",
+      command: { name: "run", arguments: "tests" },
+    })
+  })
+
+  test("returns command with multiple arguments", () => {
+    expect(parseSlashCommand("/debug fix the bug", commands)).toEqual({
+      type: "command",
+      command: { name: "debug", arguments: "fix the bug" },
+    })
+  })
+
+  test("returns pending when commands is undefined", () => {
+    expect(parseSlashCommand("/help", undefined)).toEqual({ type: "pending" })
+  })
+
+  test("returns pending when commands is null", () => {
+    expect(parseSlashCommand("/help", null as any)).toEqual({ type: "pending" })
+  })
+
+  test("handles hyphenated command names", () => {
+    expect(parseSlashCommand("/code-review", commands)).toEqual({
+      type: "command",
+      command: { name: "code-review", arguments: "" },
+    })
+  })
+
+  test("handles hyphenated command with arguments", () => {
+    expect(parseSlashCommand("/code-review please check this", commands)).toEqual({
+      type: "command",
+      command: { name: "code-review", arguments: "please check this" },
+    })
+  })
+})

package/test/command/slash-parsing.test.ts

@@ -0,0 +1,193 @@
+import { describe, expect, test } from "bun:test"
+import { isExitCommand, isNewCommand } from "@/cli/cmd/run/prompt.shared"
+
+describe("slash command parsing", () => {
+  describe("isExitCommand", () => {
+    test("recognizes /exit", () => {
+      expect(isExitCommand("/exit")).toBe(true)
+    })
+
+    test("recognizes /quit", () => {
+      expect(isExitCommand("/quit")).toBe(true)
+    })
+
+    test("recognizes :q", () => {
+      expect(isExitCommand(":q")).toBe(true)
+    })
+
+    test("is case-insensitive", () => {
+      expect(isExitCommand("/EXIT")).toBe(true)
+      expect(isExitCommand("/Quit")).toBe(true)
+      expect(isExitCommand("/EXIT")).toBe(true)
+      expect(isExitCommand(":Q")).toBe(true)
+    })
+
+    test("ignores leading/trailing whitespace", () => {
+      expect(isExitCommand("  /exit  ")).toBe(true)
+      expect(isExitCommand(" /quit ")).toBe(true)
+      expect(isExitCommand("  :q  ")).toBe(true)
+    })
+
+    test("rejects partial matches", () => {
+      expect(isExitCommand("/exiting")).toBe(false)
+      expect(isExitCommand("/quitting")).toBe(false)
+      expect(isExitCommand("/exit now")).toBe(false)
+      expect(isExitCommand("/quit now")).toBe(false)
+    })
+
+    test("rejects non-exit commands", () => {
+      expect(isExitCommand("/help")).toBe(false)
+      expect(isExitCommand("/new")).toBe(false)
+      expect(isExitCommand("/compact")).toBe(false)
+      expect(isExitCommand("hello")).toBe(false)
+      expect(isExitCommand("")).toBe(false)
+    })
+
+    test("rejects :q! and other vim variants", () => {
+      expect(isExitCommand(":q!")).toBe(false)
+      expect(isExitCommand(":wq")).toBe(false)
+      expect(isExitCommand(":x")).toBe(false)
+    })
+  })
+
+  describe("isNewCommand", () => {
+    test("recognizes /new", () => {
+      expect(isNewCommand("/new")).toBe(true)
+    })
+
+    test("is case-insensitive", () => {
+      expect(isNewCommand("/NEW")).toBe(true)
+      expect(isNewCommand("/New")).toBe(true)
+    })
+
+    test("ignores leading/trailing whitespace", () => {
+      expect(isNewCommand("  /new  ")).toBe(true)
+      expect(isNewCommand(" /NEW ")).toBe(true)
+    })
+
+    test("rejects partial matches", () => {
+      expect(isNewCommand("/new session")).toBe(false)
+      expect(isNewCommand("/newing")).toBe(false)
+      expect(isNewCommand("/newline")).toBe(false)
+    })
+
+    test("rejects non-new commands", () => {
+      expect(isNewCommand("/exit")).toBe(false)
+      expect(isNewCommand("/help")).toBe(false)
+      expect(isNewCommand("new")).toBe(false)
+      expect(isNewCommand("")).toBe(false)
+    })
+  })
+
+  describe("exit command edge cases", () => {
+    test("empty string is not exit", () => {
+      expect(isExitCommand("")).toBe(false)
+    })
+
+    test("just slash is not exit", () => {
+      expect(isExitCommand("/")).toBe(false)
+    })
+
+    test("just colon is not exit", () => {
+      expect(isExitCommand(":")).toBe(false)
+    })
+
+    test("exit without slash is not exit", () => {
+      expect(isExitCommand("exit")).toBe(false)
+    })
+
+    test("quit without slash is not exit", () => {
+      expect(isExitCommand("quit")).toBe(false)
+    })
+
+    test("q without colon is not exit", () => {
+      expect(isExitCommand("q")).toBe(false)
+    })
+  })
+
+  describe("new command edge cases", () => {
+    test("empty string is not new", () => {
+      expect(isNewCommand("")).toBe(false)
+    })
+
+    test("just slash is not new", () => {
+      expect(isNewCommand("/")).toBe(false)
+    })
+
+    test("new without slash is not new", () => {
+      expect(isNewCommand("new")).toBe(false)
+    })
+  })
+})
+
+describe("slash command in prompt text", () => {
+  test("detects slash commands at start of text", () => {
+    const texts = [
+      "/help",
+      "/exit",
+      "/new",
+      "/quit",
+      "/compact",
+      "/editor",
+      "/skills",
+      "/doctor",
+      "/cost",
+      "/run",
+      "/verify",
+      "/debug",
+      "/plan",
+      "/refactor",
+      "/code-review",
+      "/security-review",
+      "/simplify",
+      "/batch",
+      "/loop",
+      "/btw",
+      "/rewind",
+      "/teleport",
+      "/fast",
+      "/memory",
+      "/dream",
+      "/distill",
+      "/goal",
+    ]
+    for (const text of texts) {
+      expect(text.startsWith("/")).toBe(true)
+    }
+  })
+
+  test("detects slash commands with arguments", () => {
+    const texts = [
+      "/help me",
+      "/run tests",
+      "/debug this error",
+      "/plan the refactor",
+      "/btw what is this",
+      "/rewind the last change",
+      "/teleport to slack",
+      "/fast fix the bug",
+      "/goal all tests pass",
+    ]
+    for (const text of texts) {
+      expect(text.startsWith("/")).toBe(true)
+      const parts = text.split(/\s+/)
+      expect(parts[0].startsWith("/")).toBe(true)
+      expect(parts.length).toBeGreaterThan(1)
+    }
+  })
+
+  test("slash command name extraction", () => {
+    const texts = [
+      "/help",
+      "/help me",
+      "/exit",
+      "/new",
+      "/run tests",
+    ]
+    for (const text of texts) {
+      const match = text.match(/^\/(\S+)/)
+      expect(match).not.toBeNull()
+      expect(match![1]).not.toBe("")
+    }
+  })
+})