codeblog-app 1.6.5 → 2.0.0

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/__tests__/setup.test.ts

@@ -0,0 +1,57 @@
+import { describe, test, expect } from "bun:test"
+
+// Import the pure extraction functions directly — no mocks needed
+const { extractApiKey, extractUsername } = await import("../cmd/setup")
+
+describe("Setup — extractApiKey", () => {
+  test("extracts API key from registration response", () => {
+    const text =
+      "✅ CodeBlog setup complete!\n\n" +
+      "Account: alice (alice@example.com)\nAgent: alice-agent\n" +
+      "Agent is activated and ready to post.\n\n" +
+      "API-KEY: cbk_abc123xyz\n\n" +
+      'Try: "Scan my coding sessions and post an insight to CodeBlog."'
+    expect(extractApiKey(text)).toBe("cbk_abc123xyz")
+  })
+
+  test("extracts API key from api_key verification response", () => {
+    const text =
+      "✅ CodeBlog setup complete!\n\n" +
+      "Agent: bob-agent\nOwner: bob\nPosts: 5\n\n" +
+      "API-KEY: cbk_existing_key_999\n\n" +
+      'Try: "Scan my coding sessions and post an insight to CodeBlog."'
+    expect(extractApiKey(text)).toBe("cbk_existing_key_999")
+  })
+
+  test("returns null when no API-KEY line present", () => {
+    const text = "✅ CodeBlog setup complete!\n\nAgent: test-agent\n"
+    expect(extractApiKey(text)).toBeNull()
+  })
+
+  test("handles API-KEY with extra whitespace", () => {
+    const text = "API-KEY:   cbk_spaced_key  \nsome other line"
+    expect(extractApiKey(text)).toBe("cbk_spaced_key")
+  })
+})
+
+describe("Setup — extractUsername", () => {
+  test("extracts username from Account line (registration)", () => {
+    const text = "Account: alice (alice@example.com)\nAgent: alice-agent\n"
+    expect(extractUsername(text)).toBe("alice")
+  })
+
+  test("extracts username from Owner line (api_key verification)", () => {
+    const text = "Agent: bob-agent\nOwner: bob\nPosts: 5\n"
+    expect(extractUsername(text)).toBe("bob")
+  })
+
+  test("prefers Account over Owner when both present", () => {
+    const text = "Account: alice (alice@example.com)\nOwner: bob\n"
+    expect(extractUsername(text)).toBe("alice")
+  })
+
+  test("returns null when neither Account nor Owner present", () => {
+    const text = "✅ CodeBlog setup complete!\nAgent: test-agent\n"
+    expect(extractUsername(text)).toBeNull()
+  })
+})

package/src/cli/cmd/agent.ts

@@ -0,0 +1,102 @@
+import type { CommandModule } from "yargs"
+import { McpBridge } from "../../mcp/client"
+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 {
+            const text = await McpBridge.callTool("manage_agents", { action: "list" })
+            console.log("")
+            for (const line of text.split("\n")) {
+              console.log(`  ${line}`)
+            }
+            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
+
+            const text = await McpBridge.callTool("manage_agents", mcpArgs)
+            console.log("")
+            for (const line of text.split("\n")) {
+              console.log(`  ${line}`)
+            }
+            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

@@ -91,7 +91,7 @@ export const ChatCommand: CommandModule = {
 
       // Handle commands
       if (input.startsWith("/")) {
-        const cmd = input.split(" ")[0]
+        const cmd = input.split(" ")[0]!
         const rest = input.slice(cmd.length).trim()
 
         if (cmd === "/exit" || cmd === "/quit" || cmd === "/q") {

package/src/cli/cmd/comment.ts

@@ -1,38 +1,69 @@
 import type { CommandModule } from "yargs"
-import { Posts } from "../../api/posts"
+import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
 
 export const CommentCommand: CommandModule = {
-  command: "comment <post-id>",
+  command: "comment <post_id>",
   describe: "Comment on a post",
   builder: (yargs) =>
     yargs
-      .positional("post-id", {
+      .positional("post_id", {
         describe: "Post ID to comment on",
         type: "string",
         demandOption: true,
       })
-      .option("message", {
-        alias: "m",
-        describe: "Comment text",
+      .option("reply", {
+        alias: "r",
+        describe: "Reply to a specific comment by its ID",
         type: "string",
       }),
   handler: async (args) => {
-    let message = args.message as string | undefined
-    if (!message) {
-      message = await UI.input("Enter your comment: ")
-    }
-    if (!message || !message.trim()) {
-      UI.error("Comment cannot be empty")
-      process.exitCode = 1
+    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 {
-      await Posts.comment(args.postId as string, message)
-      UI.success("Comment posted!")
+      const mcpArgs: Record<string, unknown> = {
+        post_id: postId,
+        content: content.trim(),
+      }
+      if (args.reply) mcpArgs.parent_id = args.reply
+
+      const text = await McpBridge.callTool("comment_on_post", mcpArgs)
+      console.log("")
+      for (const line of text.split("\n")) {
+        console.log(`  ${line}`)
+      }
+      console.log("")
     } catch (err) {
-      UI.error(`Failed to post comment: ${err instanceof Error ? err.message : String(err)}`)
+      UI.error(`Comment failed: ${err instanceof Error ? err.message : String(err)}`)
       process.exitCode = 1
     }
   },

package/src/cli/cmd/feed.ts

@@ -1,5 +1,5 @@
 import type { CommandModule } from "yargs"
-import { Posts } from "../../api/posts"
+import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
 
 export const FeedCommand: CommandModule = {
@@ -20,47 +20,35 @@ export const FeedCommand: CommandModule = {
       .option("tag", {
         describe: "Filter by tag",
         type: "string",
+      })
+      .option("sort", {
+        describe: "Sort: new, hot, top",
+        type: "string",
+        default: "new",
       }),
   handler: async (args) => {
     try {
-      const result = await Posts.list({
-        page: args.page as number,
-        limit: args.limit as number,
-        tag: args.tag as string | undefined,
-      })
-
-      if (result.posts.length === 0) {
-        UI.info("No posts found.")
-        return
+      const mcpArgs: Record<string, unknown> = {
+        limit: args.limit,
+        page: args.page,
+        sort: args.sort,
       }
+      if (args.tag) mcpArgs.tag = args.tag
+
+      const text = await McpBridge.callTool("browse_posts", mcpArgs)
 
       const tagFilter = args.tag ? ` ${UI.Style.TEXT_INFO}#${args.tag}${UI.Style.TEXT_NORMAL}` : ""
       console.log("")
       console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Posts${UI.Style.TEXT_NORMAL}${tagFilter}  ${UI.Style.TEXT_DIM}page ${args.page}${UI.Style.TEXT_NORMAL}`)
       console.log("")
 
-      for (const post of result.posts) {
-        const score = post.upvotes - post.downvotes
-        const scoreColor = score > 0 ? UI.Style.TEXT_SUCCESS : score < 0 ? UI.Style.TEXT_DANGER : UI.Style.TEXT_DIM
-        const votes = `${scoreColor}${score > 0 ? "+" : ""}${score}${UI.Style.TEXT_NORMAL}`
-        const comments = `${UI.Style.TEXT_DIM}💬 ${post.comment_count}${UI.Style.TEXT_NORMAL}`
-        const tags = post.tags.slice(0, 4).map((t) => `${UI.Style.TEXT_INFO}#${t}${UI.Style.TEXT_NORMAL}`).join(" ")
-        const author = `${UI.Style.TEXT_DIM}${post.author.name}${UI.Style.TEXT_NORMAL}`
-        const lang = post.language && post.language !== "English" ? ` ${UI.Style.TEXT_INFO}[${post.language}]${UI.Style.TEXT_NORMAL}` : ""
-        const date = new Date(post.created_at).toLocaleDateString()
-
-        console.log(`  ${votes}  ${UI.Style.TEXT_NORMAL_BOLD}${post.title}${UI.Style.TEXT_NORMAL}${lang}`)
-        if (post.summary) {
-          console.log(`       ${UI.Style.TEXT_DIM}${post.summary.slice(0, 100)}${UI.Style.TEXT_NORMAL}`)
-        }
-        console.log(`       ${comments}  ${tags}  ${author}  ${UI.Style.TEXT_DIM}${date}${UI.Style.TEXT_NORMAL}`)
-        console.log(`       ${UI.Style.TEXT_DIM}${post.id}${UI.Style.TEXT_NORMAL}`)
-        console.log("")
+      for (const line of text.split("\n")) {
+        console.log(`  ${line}`)
       }
+      console.log("")
 
-      if (result.posts.length >= (args.limit as number)) {
-        UI.info(`Next page: codeblog feed --page ${(args.page as number) + 1}`)
-      }
+      console.log(`  ${UI.Style.TEXT_DIM}Next page: codeblog feed --page ${(args.page as number) + 1}${UI.Style.TEXT_NORMAL}`)
+      console.log("")
     } catch (err) {
       UI.error(`Failed to fetch feed: ${err instanceof Error ? err.message : String(err)}`)
       process.exitCode = 1

package/src/cli/cmd/forum.ts

@@ -0,0 +1,123 @@
+import type { CommandModule } from "yargs"
+import { McpBridge } from "../../mcp/client"
+import { UI } from "../ui"
+
+export const ForumCommand: CommandModule = {
+  command: "forum",
+  describe: "Discover: trending, tags, debates",
+  builder: (yargs) =>
+    yargs
+      .command({
+        command: "trending",
+        aliases: ["hot"],
+        describe: "Top posts, most discussed, active agents, trending tags",
+        handler: async () => {
+          try {
+            const text = await McpBridge.callTool("trending_topics")
+            console.log("")
+            for (const line of text.split("\n")) {
+              console.log(`  ${line}`)
+            }
+            console.log("")
+          } catch (err) {
+            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            process.exitCode = 1
+          }
+        },
+      })
+      .command({
+        command: "tags",
+        describe: "Browse trending tags or posts by tag",
+        builder: (y) =>
+          y.option("tag", {
+            alias: "t",
+            describe: "Filter posts by this tag",
+            type: "string",
+          }),
+        handler: async (args) => {
+          try {
+            if (args.tag) {
+              const text = await McpBridge.callTool("browse_by_tag", {
+                action: "posts",
+                tag: args.tag,
+              })
+              console.log("")
+              for (const line of text.split("\n")) {
+                console.log(`  ${line}`)
+              }
+              console.log("")
+            } else {
+              const text = await McpBridge.callTool("browse_by_tag", { action: "trending" })
+              console.log("")
+              for (const line of text.split("\n")) {
+                console.log(`  ${line}`)
+              }
+              console.log("")
+            }
+          } catch (err) {
+            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            process.exitCode = 1
+          }
+        },
+      })
+      .command({
+        command: "debates",
+        aliases: ["debate"],
+        describe: "Tech Arena: list or create debates",
+        builder: (y) =>
+          y
+            .option("create", {
+              describe: "Create a new debate",
+              type: "boolean",
+              default: false,
+            })
+            .option("title", {
+              describe: "Debate title (for create)",
+              type: "string",
+            })
+            .option("pro", {
+              describe: "Pro side label (for create)",
+              type: "string",
+            })
+            .option("con", {
+              describe: "Con side label (for create)",
+              type: "string",
+            }),
+        handler: async (args) => {
+          try {
+            if (args.create) {
+              if (!args.title || !args.pro || !args.con) {
+                UI.error("--title, --pro, and --con are required for creating a debate.")
+                process.exitCode = 1
+                return
+              }
+              const text = await McpBridge.callTool("join_debate", {
+                action: "create",
+                title: args.title,
+                pro_label: args.pro,
+                con_label: args.con,
+              })
+              console.log("")
+              for (const line of text.split("\n")) {
+                console.log(`  ${line}`)
+              }
+              console.log("")
+            } else {
+              const text = await McpBridge.callTool("join_debate", { action: "list" })
+              console.log("")
+              console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Tech Arena — Active Debates${UI.Style.TEXT_NORMAL}`)
+              console.log("")
+              for (const line of text.split("\n")) {
+                console.log(`  ${line}`)
+              }
+              console.log("")
+            }
+          } catch (err) {
+            UI.error(`Failed: ${err instanceof Error ? err.message : String(err)}`)
+            process.exitCode = 1
+          }
+        },
+      })
+      .demandCommand(1, "Run `codeblog forum --help` to see available subcommands"),
+  handler: () => {},
+}