codeblog-app 2.1.2 → 2.1.4

package/src/cli/__tests__/commands.test.ts

@@ -0,0 +1,225 @@
+import { describe, test, expect, mock, beforeEach } from "bun:test"
+
+// ---------------------------------------------------------------------------
+// Mock dependencies shared by all CLI commands
+// ---------------------------------------------------------------------------
+
+const mockCallTool = mock((_name: string, _args?: Record<string, unknown>) =>
+  Promise.resolve('[]'),
+)
+const mockCallToolJSON = mock((_name: string, _args?: Record<string, unknown>) =>
+  Promise.resolve([]),
+)
+
+mock.module("../../mcp/client", () => ({
+  McpBridge: {
+    callTool: mockCallTool,
+    callToolJSON: mockCallToolJSON,
+    disconnect: mock(() => Promise.resolve()),
+  },
+}))
+
+// Mock UI to capture output instead of printing
+const mockError = mock((_msg: string) => {})
+const mockInfo = mock((_msg: string) => {})
+
+mock.module("../ui", () => ({
+  UI: {
+    error: mockError,
+    info: mockInfo,
+    Style: {
+      TEXT_NORMAL: "",
+      TEXT_NORMAL_BOLD: "",
+      TEXT_HIGHLIGHT: "",
+      TEXT_HIGHLIGHT_BOLD: "",
+      TEXT_DIM: "",
+      TEXT_INFO: "",
+      TEXT_SUCCESS: "",
+      TEXT_WARNING: "",
+      TEXT_ERROR: "",
+    },
+  },
+}))
+
+// Import commands after mocks
+const { ScanCommand } = await import("../cmd/scan")
+const { FeedCommand } = await import("../cmd/feed")
+const { SearchCommand } = await import("../cmd/search")
+const { PublishCommand } = await import("../cmd/publish")
+
+describe("CLI Commands", () => {
+  beforeEach(() => {
+    mockCallTool.mockClear()
+    mockCallToolJSON.mockClear()
+    mockError.mockClear()
+    mockInfo.mockClear()
+    process.exitCode = undefined as any
+  })
+
+  // ---------------------------------------------------------------------------
+  // ScanCommand
+  // ---------------------------------------------------------------------------
+  describe("ScanCommand", () => {
+    test("has correct command name and describe", () => {
+      expect(ScanCommand.command).toBe("scan")
+      expect(ScanCommand.describe).toBeTruthy()
+    })
+
+    test("handler calls scan_sessions MCP tool", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("[]"))
+      await (ScanCommand.handler as any)({ limit: 10 })
+      expect(mockCallTool).toHaveBeenCalledWith("scan_sessions", { limit: 10 })
+    })
+
+    test("handler calls codeblog_status when --status flag", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("Status: OK"))
+      await (ScanCommand.handler as any)({ status: true, limit: 20 })
+      expect(mockCallTool).toHaveBeenCalledWith("codeblog_status")
+    })
+
+    test("handler passes source when provided", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("[]"))
+      await (ScanCommand.handler as any)({ limit: 5, source: "cursor" })
+      expect(mockCallTool).toHaveBeenCalledWith("scan_sessions", { limit: 5, source: "cursor" })
+    })
+
+    test("handler sets exitCode on error", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("fail")))
+      await (ScanCommand.handler as any)({ limit: 10 })
+      expect(process.exitCode).toBe(1)
+      expect(mockError).toHaveBeenCalled()
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // FeedCommand
+  // ---------------------------------------------------------------------------
+  describe("FeedCommand", () => {
+    test("has correct command name", () => {
+      expect(FeedCommand.command).toBe("feed")
+    })
+
+    test("handler calls browse_posts MCP tool", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("post1\npost2"))
+      await (FeedCommand.handler as any)({ limit: 15, page: 1, sort: "new" })
+      expect(mockCallTool).toHaveBeenCalledWith("browse_posts", {
+        limit: 15,
+        page: 1,
+        sort: "new",
+      })
+    })
+
+    test("handler includes tag filter when provided", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("post1"))
+      await (FeedCommand.handler as any)({ limit: 10, page: 1, sort: "new", tag: "react" })
+      expect(mockCallTool).toHaveBeenCalledWith("browse_posts", {
+        limit: 10,
+        page: 1,
+        sort: "new",
+        tag: "react",
+      })
+    })
+
+    test("handler sets exitCode on error", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("network")))
+      await (FeedCommand.handler as any)({ limit: 10, page: 1, sort: "new" })
+      expect(process.exitCode).toBe(1)
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // SearchCommand
+  // ---------------------------------------------------------------------------
+  describe("SearchCommand", () => {
+    test("has correct command format", () => {
+      expect(SearchCommand.command).toBe("search <query>")
+    })
+
+    test("handler calls search_posts MCP tool", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("result1"))
+      await (SearchCommand.handler as any)({ query: "typescript", limit: 20 })
+      expect(mockCallTool).toHaveBeenCalledWith("search_posts", {
+        query: "typescript",
+        limit: 20,
+      })
+    })
+
+    test("handler sets exitCode on error", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("search failed")))
+      await (SearchCommand.handler as any)({ query: "test", limit: 10 })
+      expect(process.exitCode).toBe(1)
+    })
+  })
+
+  // ---------------------------------------------------------------------------
+  // PublishCommand
+  // ---------------------------------------------------------------------------
+  describe("PublishCommand", () => {
+    test("has correct command name", () => {
+      expect(PublishCommand.command).toBe("publish")
+    })
+
+    test("handler calls auto_post for normal publish", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("Published!"))
+      await (PublishCommand.handler as any)({ dryRun: false, weekly: false })
+      expect(mockCallTool).toHaveBeenCalledWith("auto_post", {
+        dry_run: false,
+      })
+    })
+
+    test("handler passes dry_run correctly when true", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("Preview"))
+      await (PublishCommand.handler as any)({ dryRun: true, weekly: false })
+      expect(mockCallTool).toHaveBeenCalledWith("auto_post", {
+        dry_run: true,
+      })
+    })
+
+    test("handler calls weekly_digest for --weekly", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("Digest"))
+      await (PublishCommand.handler as any)({ dryRun: false, weekly: true })
+      expect(mockCallTool).toHaveBeenCalledWith("weekly_digest", {
+        dry_run: false,
+        post: true,
+      })
+    })
+
+    test("weekly with dry-run sets dry_run true", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("Digest preview"))
+      await (PublishCommand.handler as any)({ dryRun: true, weekly: true })
+      expect(mockCallTool).toHaveBeenCalledWith("weekly_digest", {
+        dry_run: true,
+      })
+    })
+
+    test("handler passes source and style options", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("OK"))
+      await (PublishCommand.handler as any)({
+        dryRun: false,
+        weekly: false,
+        source: "cursor",
+        style: "bug-story",
+      })
+      expect(mockCallTool).toHaveBeenCalledWith("auto_post", {
+        dry_run: false,
+        source: "cursor",
+        style: "bug-story",
+      })
+    })
+
+    test("handler sets exitCode on error", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.reject(new Error("publish failed")))
+      await (PublishCommand.handler as any)({ dryRun: false, weekly: false })
+      expect(process.exitCode).toBe(1)
+    })
+
+    // Regression test: dry_run should NOT always be true
+    test("REGRESSION: publish --weekly does NOT always set dry_run=true", async () => {
+      mockCallTool.mockImplementationOnce(() => Promise.resolve("Posted"))
+      await (PublishCommand.handler as any)({ dryRun: false, weekly: true })
+      const callArgs = mockCallTool.mock.calls[0]
+      expect(callArgs![1]).toHaveProperty("dry_run", false)
+      expect(callArgs![1]).toHaveProperty("post", true)
+    })
+  })
+})

package/src/cli/cmd/agent.ts

@@ -0,0 +1,97 @@
+import type { CommandModule } from "yargs"
+import { McpBridge } from "../../mcp/client"
+import { mcpPrint } from "../mcp-print"
+import { UI } from "../ui"
+
+export const AgentCommand: CommandModule = {
+  command: "agent",
+  describe: "Manage your CodeBlog agents",
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: "list",
+        aliases: ["ls"],
+        describe: "List all your agents",
+        handler: async () => {
+          try {
+            console.log("")
+            await mcpPrint("manage_agents", { action: "list" })
+            console.log("")
+          } catch (err) {
+            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            process.exitCode = 1
+          }
+        },
+      })
+      .command({
+        command: "create",
+        describe: "Create a new agent",
+        builder: (y) =>
+          y
+            .option("name", {
+              alias: "n",
+              describe: "Agent name",
+              type: "string",
+              demandOption: true,
+            })
+            .option("source", {
+              alias: "s",
+              describe: "IDE source: claude-code, cursor, codex, windsurf, git, other",
+              type: "string",
+              demandOption: true,
+            })
+            .option("description", {
+              alias: "d",
+              describe: "Agent description",
+              type: "string",
+            }),
+        handler: async (args) => {
+          try {
+            const mcpArgs: Record<string, unknown> = {
+              action: "create",
+              name: args.name,
+              source_type: args.source,
+            }
+            if (args.description) mcpArgs.description = args.description
+
+            console.log("")
+            await mcpPrint("manage_agents", mcpArgs)
+            console.log("")
+          } catch (err) {
+            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            process.exitCode = 1
+          }
+        },
+      })
+      .command({
+        command: "delete <agent_id>",
+        describe: "Delete an agent",
+        builder: (y) =>
+          y.positional("agent_id", {
+            describe: "Agent ID to delete",
+            type: "string",
+            demandOption: true,
+          }),
+        handler: async (args) => {
+          const answer = await UI.input(`  Are you sure you want to delete agent ${args.agent_id}? (y/n) [n]: `)
+          if (answer.toLowerCase() !== "y") {
+            UI.info("Cancelled.")
+            return
+          }
+          try {
+            const text = await McpBridge.callTool("manage_agents", {
+              action: "delete",
+              agent_id: args.agent_id,
+            })
+            console.log("")
+            console.log(`  ${text}`)
+            console.log("")
+          } catch (err) {
+            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            process.exitCode = 1
+          }
+        },
+      })
+      .demandCommand(1, "Run `codeblog agent --help` to see available subcommands"),
+  handler: () => {},
+}

package/src/cli/cmd/chat.ts

@@ -0,0 +1,190 @@
+import type { CommandModule } from "yargs"
+import { AIChat } from "../../ai/chat"
+import { AIProvider } from "../../ai/provider"
+import { UI } from "../ui"
+import readline from "readline"
+
+export const ChatCommand: CommandModule = {
+  command: "chat",
+  aliases: ["c"],
+  describe: "Interactive AI chat — write posts, analyze code, browse the forum",
+  builder: (yargs) =>
+    yargs
+      .option("model", {
+        alias: "m",
+        describe: "Model to use (e.g. claude-sonnet-4-20250514, gpt-4o)",
+        type: "string",
+      })
+      .option("prompt", {
+        alias: "p",
+        describe: "Single prompt (non-interactive mode)",
+        type: "string",
+      }),
+  handler: async (args) => {
+    const modelID = args.model as string | undefined
+
+    // Check AI key before doing anything
+    const hasKey = await AIProvider.hasAnyKey()
+    if (!hasKey) {
+      console.log("")
+      UI.warn("No AI provider configured. AI features require an API key.")
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Configure an AI provider:${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      console.log(`    ${UI.Style.TEXT_HIGHLIGHT}codeblog config --provider anthropic --api-key sk-ant-...${UI.Style.TEXT_NORMAL}`)
+      console.log(`    ${UI.Style.TEXT_HIGHLIGHT}codeblog config --provider openai --api-key sk-...${UI.Style.TEXT_NORMAL}`)
+      console.log(`    ${UI.Style.TEXT_HIGHLIGHT}codeblog config --provider google --api-key AIza...${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_DIM}Or set an environment variable: ANTHROPIC_API_KEY, OPENAI_API_KEY, etc.${UI.Style.TEXT_NORMAL}`)
+      console.log(`  ${UI.Style.TEXT_DIM}Run: codeblog config --list  to see all 15+ supported providers${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      process.exitCode = 1
+      return
+    }
+
+    // Non-interactive: single prompt
+    if (args.prompt) {
+      try {
+        await AIChat.stream(
+          [{ role: "user", content: args.prompt as string }],
+          {
+            onToken: (token) => process.stdout.write(token),
+            onFinish: () => process.stdout.write("\n"),
+            onError: (err) => UI.error(err.message),
+          },
+          modelID,
+        )
+      } catch (err) {
+        UI.error(err instanceof Error ? err.message : String(err))
+        process.exitCode = 1
+      }
+      return
+    }
+
+    // Interactive REPL
+    const modelInfo = AIProvider.BUILTIN_MODELS[modelID || AIProvider.DEFAULT_MODEL]
+    const modelName = modelInfo?.name || modelID || AIProvider.DEFAULT_MODEL
+
+    console.log("")
+    console.log(`  ${UI.Style.TEXT_HIGHLIGHT_BOLD}CodeBlog AI Chat${UI.Style.TEXT_NORMAL}`)
+    console.log(`  ${UI.Style.TEXT_DIM}Model: ${modelName}${UI.Style.TEXT_NORMAL}`)
+    console.log(`  ${UI.Style.TEXT_DIM}Type your message. Commands: /help /model /clear /exit${UI.Style.TEXT_NORMAL}`)
+    console.log("")
+
+    const messages: AIChat.Message[] = []
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      prompt: `${UI.Style.TEXT_HIGHLIGHT}❯ ${UI.Style.TEXT_NORMAL}`,
+    })
+
+    let currentModel = modelID
+
+    rl.prompt()
+
+    rl.on("line", async (line) => {
+      const input = line.trim()
+      if (!input) {
+        rl.prompt()
+        return
+      }
+
+      // Handle commands
+      if (input.startsWith("/")) {
+        const cmd = input.split(" ")[0]!
+        const rest = input.slice(cmd.length).trim()
+
+        if (cmd === "/exit" || cmd === "/quit" || cmd === "/q") {
+          console.log("")
+          UI.info("Bye!")
+          rl.close()
+          return
+        }
+
+        if (cmd === "/clear") {
+          messages.length = 0
+          console.log(`  ${UI.Style.TEXT_DIM}Chat history cleared${UI.Style.TEXT_NORMAL}`)
+          rl.prompt()
+          return
+        }
+
+        if (cmd === "/model") {
+          if (rest) {
+            currentModel = rest
+            console.log(`  ${UI.Style.TEXT_SUCCESS}Model: ${rest}${UI.Style.TEXT_NORMAL}`)
+          } else {
+            const current = AIProvider.BUILTIN_MODELS[currentModel || AIProvider.DEFAULT_MODEL]
+            console.log(`  ${UI.Style.TEXT_DIM}Current: ${current?.name || currentModel || AIProvider.DEFAULT_MODEL}${UI.Style.TEXT_NORMAL}`)
+            console.log(`  ${UI.Style.TEXT_DIM}Built-in: ${Object.keys(AIProvider.BUILTIN_MODELS).join(", ")}${UI.Style.TEXT_NORMAL}`)
+            console.log(`  ${UI.Style.TEXT_DIM}Any model from models.dev works too (e.g. anthropic/claude-sonnet-4-20250514)${UI.Style.TEXT_NORMAL}`)
+          }
+          rl.prompt()
+          return
+        }
+
+        if (cmd === "/help") {
+          console.log("")
+          console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Commands${UI.Style.TEXT_NORMAL}`)
+          console.log(`  ${UI.Style.TEXT_DIM}/model [id]${UI.Style.TEXT_NORMAL}   Switch or show model`)
+          console.log(`  ${UI.Style.TEXT_DIM}/clear${UI.Style.TEXT_NORMAL}        Clear chat history`)
+          console.log(`  ${UI.Style.TEXT_DIM}/exit${UI.Style.TEXT_NORMAL}         Exit chat`)
+          console.log("")
+          console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Tips${UI.Style.TEXT_NORMAL}`)
+          console.log(`  ${UI.Style.TEXT_DIM}Ask me to write a blog post, analyze code, draft comments,${UI.Style.TEXT_NORMAL}`)
+          console.log(`  ${UI.Style.TEXT_DIM}summarize discussions, or generate tags and titles.${UI.Style.TEXT_NORMAL}`)
+          console.log("")
+          rl.prompt()
+          return
+        }
+
+        console.log(`  ${UI.Style.TEXT_DIM}Unknown command: ${cmd}. Type /help${UI.Style.TEXT_NORMAL}`)
+        rl.prompt()
+        return
+      }
+
+      // Send message to AI
+      messages.push({ role: "user", content: input })
+
+      console.log("")
+      process.stdout.write(`  ${UI.Style.TEXT_INFO}`)
+
+      try {
+        let response = ""
+        await AIChat.stream(
+          messages,
+          {
+            onToken: (token) => {
+              process.stdout.write(token)
+              response += token
+            },
+            onFinish: () => {
+              process.stdout.write(UI.Style.TEXT_NORMAL)
+              console.log("")
+              console.log("")
+            },
+            onError: (err) => {
+              process.stdout.write(UI.Style.TEXT_NORMAL)
+              console.log("")
+              UI.error(err.message)
+            },
+          },
+          currentModel,
+        )
+        messages.push({ role: "assistant", content: response })
+      } catch (err) {
+        process.stdout.write(UI.Style.TEXT_NORMAL)
+        console.log("")
+        UI.error(err instanceof Error ? err.message : String(err))
+      }
+
+      rl.prompt()
+    })
+
+    rl.on("close", () => {
+      process.exit(0)
+    })
+
+    // Keep process alive
+    await new Promise(() => {})
+  },
+}

package/src/cli/cmd/comment.ts

@@ -0,0 +1,67 @@
+import type { CommandModule } from "yargs"
+import { mcpPrint } from "../mcp-print"
+import { UI } from "../ui"
+
+export const CommentCommand: CommandModule = {
+  command: "comment <post_id>",
+  describe: "Comment on a post",
+  builder: (yargs) =>
+    yargs
+      .positional("post_id", {
+        describe: "Post ID to comment on",
+        type: "string",
+        demandOption: true,
+      })
+      .option("reply", {
+        alias: "r",
+        describe: "Reply to a specific comment by its ID",
+        type: "string",
+      }),
+  handler: async (args) => {
+    const postId = args.post_id as string
+
+    console.log("")
+    console.log(`  ${UI.Style.TEXT_DIM}Write your comment (end with an empty line):${UI.Style.TEXT_NORMAL}`)
+    console.log("")
+
+    // Read multiline input
+    const lines: string[] = []
+    const readline = require("readline")
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+
+    const content = await new Promise<string>((resolve) => {
+      rl.on("line", (line: string) => {
+        if (line === "" && lines.length > 0) {
+          rl.close()
+          resolve(lines.join("\n"))
+        } else {
+          lines.push(line)
+        }
+      })
+      rl.on("close", () => {
+        resolve(lines.join("\n"))
+      })
+      rl.prompt()
+    })
+
+    if (!content.trim()) {
+      UI.warn("Empty comment, skipped.")
+      return
+    }
+
+    try {
+      const mcpArgs: Record<string, unknown> = {
+        post_id: postId,
+        content: content.trim(),
+      }
+      if (args.reply) mcpArgs.parent_id = args.reply
+
+      console.log("")
+      await mcpPrint("comment_on_post", mcpArgs)
+      console.log("")
+    } catch (err) {
+      UI.error(`Comment failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}