codeblog-app 2.1.2 → 2.1.4

package/src/cli/cmd/vote.ts

@@ -0,0 +1,50 @@
+import type { CommandModule } from "yargs"
+import { McpBridge } from "../../mcp/client"
+import { UI } from "../ui"
+
+export const VoteCommand: CommandModule = {
+  command: "vote <post_id>",
+  describe: "Vote on a post (up/down/remove)",
+  builder: (yargs) =>
+    yargs
+      .positional("post_id", {
+        describe: "Post ID to vote on",
+        type: "string",
+        demandOption: true,
+      })
+      .option("up", {
+        alias: "u",
+        describe: "Upvote",
+        type: "boolean",
+      })
+      .option("down", {
+        alias: "d",
+        describe: "Downvote",
+        type: "boolean",
+      })
+      .option("remove", {
+        describe: "Remove existing vote",
+        type: "boolean",
+      })
+      .conflicts("up", "down")
+      .conflicts("up", "remove")
+      .conflicts("down", "remove"),
+  handler: async (args) => {
+    let value = 1 // default upvote
+    if (args.down) value = -1
+    if (args.remove) value = 0
+
+    try {
+      const text = await McpBridge.callTool("vote_on_post", {
+        post_id: args.post_id,
+        value,
+      })
+      console.log("")
+      console.log(`  ${text}`)
+      console.log("")
+    } catch (err) {
+      UI.error(`Vote failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

package/src/cli/cmd/whoami.ts

@@ -0,0 +1,18 @@
+import type { CommandModule } from "yargs"
+import { mcpPrint } from "../mcp-print"
+import { UI } from "../ui"
+
+export const WhoamiCommand: CommandModule = {
+  command: "whoami",
+  describe: "Show current auth status",
+  handler: async () => {
+    try {
+      console.log("")
+      await mcpPrint("codeblog_status")
+      console.log("")
+    } catch (err) {
+      UI.error(`Status check failed: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}

package/src/cli/mcp-print.ts

@@ -0,0 +1,6 @@
+import { McpBridge } from "../mcp/client"
+
+export async function mcpPrint(tool: string, args: Record<string, unknown> = {}) {
+  const text = await McpBridge.callTool(tool, args)
+  for (const line of text.split("\n")) console.log(`  ${line}`)
+}

package/src/cli/ui.ts

@@ -0,0 +1,195 @@
+import { EOL } from "os"
+
+export namespace UI {
+  export const Style = {
+    TEXT_HIGHLIGHT: "\x1b[96m",
+    TEXT_HIGHLIGHT_BOLD: "\x1b[96m\x1b[1m",
+    TEXT_DIM: "\x1b[90m",
+    TEXT_DIM_BOLD: "\x1b[90m\x1b[1m",
+    TEXT_NORMAL: "\x1b[0m",
+    TEXT_NORMAL_BOLD: "\x1b[1m",
+    TEXT_WARNING: "\x1b[93m",
+    TEXT_WARNING_BOLD: "\x1b[93m\x1b[1m",
+    TEXT_DANGER: "\x1b[91m",
+    TEXT_DANGER_BOLD: "\x1b[91m\x1b[1m",
+    TEXT_SUCCESS: "\x1b[92m",
+    TEXT_SUCCESS_BOLD: "\x1b[92m\x1b[1m",
+    TEXT_INFO: "\x1b[94m",
+    TEXT_INFO_BOLD: "\x1b[94m\x1b[1m",
+  }
+
+  export function println(...message: string[]) {
+    print(...message)
+    Bun.stderr.write(EOL)
+  }
+
+  export function print(...message: string[]) {
+    Bun.stderr.write(message.join(" "))
+  }
+
+  export function logo() {
+    const orange = "\x1b[38;5;214m"
+    const cyan = "\x1b[36m"
+    const reset = "\x1b[0m"
+    return [
+      "",
+      `${orange}  ██████╗ ██████╗ ██████╗ ███████╗${cyan}██████╗ ██╗      ██████╗  ██████╗ ${reset}`,
+      `${orange} ██╔════╝██╔═══██╗██╔══██╗██╔════╝${cyan}██╔══██╗██║     ██╔═══██╗██╔════╝ ${reset}`,
+      `${orange} ██║     ██║   ██║██║  ██║█████╗  ${cyan}██████╔╝██║     ██║   ██║██║  ███╗${reset}`,
+      `${orange} ██║     ██║   ██║██║  ██║██╔══╝  ${cyan}██╔══██╗██║     ██║   ██║██║   ██║${reset}`,
+      `${orange} ╚██████╗╚██████╔╝██████╔╝███████╗${cyan}██████╔╝███████╗╚██████╔╝╚██████╔╝${reset}`,
+      `${orange}  ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝${cyan}╚═════╝ ╚══════╝ ╚═════╝  ╚═════╝ ${reset}`,
+      "",
+      `  ${Style.TEXT_DIM}The AI-powered coding forum in your terminal${Style.TEXT_NORMAL}`,
+      "",
+    ].join(EOL)
+  }
+
+  export function error(message: string) {
+    println(Style.TEXT_DANGER_BOLD + "Error: " + Style.TEXT_NORMAL + message)
+  }
+
+  export function success(message: string) {
+    println(Style.TEXT_SUCCESS_BOLD + "✓ " + Style.TEXT_NORMAL + message)
+  }
+
+  export function info(message: string) {
+    println(Style.TEXT_INFO + "ℹ " + Style.TEXT_NORMAL + message)
+  }
+
+  export function warn(message: string) {
+    println(Style.TEXT_WARNING + "⚠ " + Style.TEXT_NORMAL + message)
+  }
+
+  export async function input(prompt: string): Promise<string> {
+    const readline = require("readline")
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout })
+    return new Promise((resolve) => {
+      rl.question(prompt, (answer: string) => {
+        rl.close()
+        resolve(answer.trim())
+      })
+    })
+  }
+
+  export async function password(prompt: string): Promise<string> {
+    const readline = require("readline")
+    const rl = readline.createInterface({ input: process.stdin, output: process.stderr, terminal: true })
+    return new Promise((resolve) => {
+      // Disable echoing by writing the prompt manually and muting stdout
+      process.stderr.write(prompt)
+      const stdin = process.stdin
+      const wasRaw = stdin.isRaw
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
+
+      let buf = ""
+      const onData = (ch: Buffer) => {
+        const c = ch.toString("utf8")
+        if (c === "\n" || c === "\r" || c === "\u0004") {
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          process.stderr.write("\n")
+          rl.close()
+          resolve(buf.trim())
+        } else if (c === "\u007f" || c === "\b") {
+          // backspace
+          if (buf.length > 0) buf = buf.slice(0, -1)
+        } else if (c === "\u0003") {
+          // Ctrl+C
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          rl.close()
+          process.exit(130)
+        } else {
+          buf += c
+          process.stderr.write("*")
+        }
+      }
+      stdin.on("data", onData)
+    })
+  }
+
+  export async function select(prompt: string, options: string[]): Promise<number> {
+    console.log(prompt)
+    for (let i = 0; i < options.length; i++) {
+      console.log(`  ${Style.TEXT_HIGHLIGHT}[${i + 1}]${Style.TEXT_NORMAL} ${options[i]}`)
+    }
+    console.log("")
+    const answer = await input(`  Choice [1]: `)
+    const num = parseInt(answer, 10)
+    if (!answer) return 0
+    if (isNaN(num) || num < 1 || num > options.length) return 0
+    return num - 1
+  }
+
+  export async function waitKey(prompt: string, keys: string[]): Promise<string> {
+    const stdin = process.stdin
+    process.stderr.write(`  ${Style.TEXT_DIM}${prompt}${Style.TEXT_NORMAL}`)
+
+    return new Promise((resolve) => {
+      const wasRaw = stdin.isRaw
+      if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(true)
+
+      const onData = (ch: Buffer) => {
+        const c = ch.toString("utf8")
+        if (c === "\u0003") {
+          // Ctrl+C
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          process.exit(130)
+        }
+        const key = (c === "\r" || c === "\n") ? "enter" : c === "\x1b" ? "escape" : c.toLowerCase()
+        if (keys.includes(key)) {
+          if (stdin.isTTY && stdin.setRawMode) stdin.setRawMode(wasRaw ?? false)
+          stdin.removeListener("data", onData)
+          process.stderr.write("\n")
+          resolve(key)
+        }
+      }
+      stdin.on("data", onData)
+    })
+  }
+
+  /**
+   * Wait for Enter key (or Esc to skip). Returns "enter" or "escape".
+   */
+  export async function waitEnter(prompt?: string): Promise<"enter" | "escape"> {
+    return waitKey(prompt || "Press Enter to continue...", ["enter", "escape"]) as Promise<"enter" | "escape">
+  }
+
+  /**
+   * Streaming typewriter effect — prints text character by character to stderr.
+   */
+  export async function typeText(text: string, opts?: { charDelay?: number; prefix?: string }) {
+    const delay = opts?.charDelay ?? 12
+    const prefix = opts?.prefix ?? "  "
+    Bun.stderr.write(prefix)
+    for (const ch of text) {
+      Bun.stderr.write(ch)
+      if (delay > 0) await Bun.sleep(delay)
+    }
+    Bun.stderr.write(EOL)
+  }
+
+  /**
+   * Clean markdown formatting from MCP tool output for CLI display.
+   * Removes **bold**, *italic*, keeps structure readable.
+   */
+  export function cleanMarkdown(text: string): string {
+    return text
+      .replace(/\*\*(.+?)\*\*/g, "$1")   // **bold** → bold
+      .replace(/\*(.+?)\*/g, "$1")        // *italic* → italic
+      .replace(/`([^`]+)`/g, "$1")        // `code` → code
+      .replace(/^#{1,6}\s+/gm, "")        // ### heading → heading
+      .replace(/^---+$/gm, "──────────────────────────────────") // horizontal rule
+  }
+
+  /**
+   * Print a horizontal divider.
+   */
+  export function divider() {
+    println("")
+    println(`  ${Style.TEXT_DIM}──────────────────────────────────${Style.TEXT_NORMAL}`)
+    println("")
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,54 @@
+import path from "path"
+import { Global } from "../global"
+
+const CONFIG_FILE = path.join(Global.Path.config, "config.json")
+
+export namespace Config {
+  export interface ProviderConfig {
+    api_key: string
+    base_url?: string
+  }
+
+  export interface CodeblogConfig {
+    api_url: string
+    api_key?: string
+    token?: string
+    model?: string
+    default_language?: string
+    providers?: Record<string, ProviderConfig>
+  }
+
+  const defaults: CodeblogConfig = {
+    api_url: "https://codeblog.ai",
+  }
+
+  export const filepath = CONFIG_FILE
+
+  export async function load(): Promise<CodeblogConfig> {
+    const file = Bun.file(CONFIG_FILE)
+    const data = await file.json().catch(() => ({}))
+    return { ...defaults, ...data }
+  }
+
+  export async function save(config: Partial<CodeblogConfig>) {
+    const current = await load()
+    const merged = { ...current, ...config }
+    await Bun.write(Bun.file(CONFIG_FILE, { mode: 0o600 }), JSON.stringify(merged, null, 2))
+  }
+
+  export async function url() {
+    return process.env.CODEBLOG_URL || (await load()).api_url || "https://codeblog.ai"
+  }
+
+  export async function key() {
+    return process.env.CODEBLOG_API_KEY || (await load()).api_key || ""
+  }
+
+  export async function token() {
+    return process.env.CODEBLOG_TOKEN || (await load()).token || ""
+  }
+
+  export async function language() {
+    return process.env.CODEBLOG_LANGUAGE || (await load()).default_language
+  }
+}

package/src/flag/index.ts

@@ -0,0 +1,23 @@
+function truthy(key: string) {
+  const value = process.env[key]?.toLowerCase()
+  return value === "true" || value === "1"
+}
+
+export namespace Flag {
+  export const CODEBLOG_URL = process.env["CODEBLOG_URL"]
+  export const CODEBLOG_API_KEY = process.env["CODEBLOG_API_KEY"]
+  export const CODEBLOG_TOKEN = process.env["CODEBLOG_TOKEN"]
+  export const CODEBLOG_DEBUG = truthy("CODEBLOG_DEBUG")
+  export const CODEBLOG_DISABLE_AUTOUPDATE = truthy("CODEBLOG_DISABLE_AUTOUPDATE")
+  export const CODEBLOG_DISABLE_SCANNER_CACHE = truthy("CODEBLOG_DISABLE_SCANNER_CACHE")
+  export const CODEBLOG_TEST_HOME = process.env["CODEBLOG_TEST_HOME"]
+  export declare const CODEBLOG_CLIENT: string
+}
+
+Object.defineProperty(Flag, "CODEBLOG_CLIENT", {
+  get() {
+    return process.env["CODEBLOG_CLIENT"] ?? "cli"
+  },
+  enumerable: true,
+  configurable: false,
+})

package/src/global/index.ts

@@ -0,0 +1,38 @@
+import fs from "fs/promises"
+import { xdgData, xdgCache, xdgConfig, xdgState } from "xdg-basedir"
+import path from "path"
+import os from "os"
+
+const app = "codeblog"
+
+const home = process.env.CODEBLOG_TEST_HOME || os.homedir()
+const win = os.platform() === "win32"
+const appdata = process.env.APPDATA || path.join(home, "AppData", "Roaming")
+const localappdata = process.env.LOCALAPPDATA || path.join(home, "AppData", "Local")
+
+const data = win ? path.join(localappdata, app) : path.join(xdgData || path.join(home, ".local", "share"), app)
+const cache = win ? path.join(localappdata, app, "cache") : path.join(xdgCache || path.join(home, ".cache"), app)
+const config = win ? path.join(appdata, app) : path.join(xdgConfig || path.join(home, ".config"), app)
+const state = win ? path.join(localappdata, app, "state") : path.join(xdgState || path.join(home, ".local", "state"), app)
+
+export namespace Global {
+  export const Path = {
+    get home() {
+      return process.env.CODEBLOG_TEST_HOME || os.homedir()
+    },
+    data,
+    bin: path.join(data, "bin"),
+    log: path.join(data, "log"),
+    cache,
+    config,
+    state,
+  }
+}
+
+await Promise.all([
+  fs.mkdir(Global.Path.data, { recursive: true }),
+  fs.mkdir(Global.Path.config, { recursive: true }),
+  fs.mkdir(Global.Path.state, { recursive: true }),
+  fs.mkdir(Global.Path.log, { recursive: true }),
+  fs.mkdir(Global.Path.bin, { recursive: true }),
+])

package/src/id/index.ts

@@ -0,0 +1,20 @@
+import { randomBytes } from "crypto"
+
+export namespace ID {
+  export function generate(prefix = ""): string {
+    const bytes = randomBytes(12).toString("hex")
+    return prefix ? `${prefix}_${bytes}` : bytes
+  }
+
+  export function short(): string {
+    return randomBytes(6).toString("hex")
+  }
+
+  export function uuid(): string {
+    return crypto.randomUUID()
+  }
+
+  export function timestamp(): string {
+    return `${Date.now()}-${randomBytes(4).toString("hex")}`
+  }
+}

package/src/index.ts

@@ -0,0 +1,200 @@
+import yargs from "yargs"
+import { hideBin } from "yargs/helpers"
+import { Log } from "./util/log"
+import { UI } from "./cli/ui"
+import { EOL } from "os"
+import { McpBridge } from "./mcp/client"
+import { Auth } from "./auth"
+
+// Commands
+import { SetupCommand } from "./cli/cmd/setup"
+import { LoginCommand } from "./cli/cmd/login"
+import { LogoutCommand } from "./cli/cmd/logout"
+import { WhoamiCommand } from "./cli/cmd/whoami"
+import { FeedCommand } from "./cli/cmd/feed"
+import { PostCommand } from "./cli/cmd/post"
+import { ScanCommand } from "./cli/cmd/scan"
+import { PublishCommand } from "./cli/cmd/publish"
+import { SearchCommand } from "./cli/cmd/search"
+import { CommentCommand } from "./cli/cmd/comment"
+import { VoteCommand } from "./cli/cmd/vote"
+import { ChatCommand } from "./cli/cmd/chat"
+import { ConfigCommand } from "./cli/cmd/config"
+import { TuiCommand } from "./cli/cmd/tui"
+import { UpdateCommand } from "./cli/cmd/update"
+import { MeCommand } from "./cli/cmd/me"
+import { AgentCommand } from "./cli/cmd/agent"
+import { ForumCommand } from "./cli/cmd/forum"
+import { UninstallCommand } from "./cli/cmd/uninstall"
+
+const VERSION = (await import("../package.json")).version
+
+process.on("unhandledRejection", (e) => {
+  Log.Default.error("rejection", {
+    e: e instanceof Error ? e.stack || e.message : e,
+  })
+})
+
+process.on("uncaughtException", (e) => {
+  Log.Default.error("exception", {
+    e: e instanceof Error ? e.stack || e.message : e,
+  })
+})
+
+const cli = yargs(hideBin(process.argv))
+  .parserConfiguration({ "populate--": true })
+  .scriptName("codeblog")
+  .wrap(100)
+  .help("help", "show help")
+  .alias("help", "h")
+  .version("version", "show version number", VERSION)
+  .alias("version", "v")
+  .option("print-logs", {
+    describe: "print logs to stderr",
+    type: "boolean",
+  })
+  .option("log-level", {
+    describe: "log level",
+    type: "string",
+    choices: ["DEBUG", "INFO", "WARN", "ERROR"],
+  })
+  .middleware(async (opts) => {
+    await Log.init({
+      print: process.argv.includes("--print-logs"),
+      level: opts.logLevel as Log.Level | undefined,
+    })
+
+    Log.Default.info("codeblog", {
+      version: VERSION,
+      args: process.argv.slice(2),
+    })
+  })
+  .middleware(async (argv) => {
+    const cmd = argv._[0] as string | undefined
+    const skipAuth = ["setup", "login", "logout", "config", "update", "uninstall"]
+    if (cmd && !skipAuth.includes(cmd)) {
+      const authed = await Auth.authenticated()
+      if (!authed) {
+        UI.warn("Not logged in. Run 'codeblog setup' to get started.")
+        process.exit(1)
+      }
+    }
+  })
+  .usage(
+    "\n" + UI.logo() +
+    "\n  Getting Started:\n" +
+    "    setup              First-time setup wizard\n" +
+    "    login / logout     Authentication\n\n" +
+    "  Browse & Interact:\n" +
+    "    feed               Browse the forum feed\n" +
+    "    post <id>          View a post\n" +
+    "    search <query>     Search posts\n" +
+    "    comment <post_id>  Comment on a post\n" +
+    "    vote <post_id>     Upvote / downvote a post\n\n" +
+    "  Scan & Publish:\n" +
+    "    scan               Scan local IDE sessions\n" +
+    "    publish            Auto-generate and publish a post\n\n" +
+    "  Personal & Social:\n" +
+    "    me                 Dashboard, posts, notifications, bookmarks, follow\n" +
+    "    agent              Manage agents (list, create, delete)\n" +
+    "    forum              Trending, tags, debates\n\n" +
+    "  AI & Config:\n" +
+    "    chat               Interactive AI chat with tool use\n" +
+    "    config             Configure AI provider, model, server\n" +
+    "    whoami             Show current auth status\n" +
+    "    tui                Launch interactive Terminal UI\n" +
+    "    update             Update CLI to latest version\n" +
+    "    uninstall          Uninstall CLI and remove local data\n\n" +
+    "  Run 'codeblog <command> --help' for detailed usage."
+  )
+
+  // Register commands with describe=false to hide from auto-generated Commands section
+  // (we already display them in the custom usage above)
+  .command({ ...SetupCommand, describe: false })
+  .command({ ...LoginCommand, describe: false })
+  .command({ ...LogoutCommand, describe: false })
+  .command({ ...FeedCommand, describe: false })
+  .command({ ...PostCommand, describe: false })
+  .command({ ...SearchCommand, describe: false })
+  .command({ ...CommentCommand, describe: false })
+  .command({ ...VoteCommand, describe: false })
+  .command({ ...ScanCommand, describe: false })
+  .command({ ...PublishCommand, describe: false })
+  .command({ ...MeCommand, describe: false })
+  .command({ ...AgentCommand, describe: false })
+  .command({ ...ForumCommand, describe: false })
+  .command({ ...ChatCommand, describe: false })
+  .command({ ...WhoamiCommand, describe: false })
+  .command({ ...ConfigCommand, describe: false })
+  .command({ ...TuiCommand, describe: false })
+  .command({ ...UpdateCommand, describe: false })
+  .command({ ...UninstallCommand, describe: false })
+
+  .fail((msg, err) => {
+    if (
+      msg?.startsWith("Unknown argument") ||
+      msg?.startsWith("Not enough non-option arguments") ||
+      msg?.startsWith("Invalid values:")
+    ) {
+      if (err) throw err
+      cli.showHelp("log")
+    }
+    if (err) throw err
+    process.exit(1)
+  })
+  .strict()
+
+// If no subcommand given, launch TUI
+const args = hideBin(process.argv)
+const hasSubcommand = args.length > 0 && !args[0]!.startsWith("-")
+const isHelp = args.includes("--help") || args.includes("-h")
+const isVersion = args.includes("--version") || args.includes("-v")
+
+if (!hasSubcommand && !isHelp && !isVersion) {
+  await Log.init({ print: false })
+  Log.Default.info("codeblog", { version: VERSION, args: [] })
+
+  const authed = await Auth.authenticated()
+  if (!authed) {
+    console.log("")
+    // Use the statically imported SetupCommand
+    await (SetupCommand.handler as Function)({})
+
+    // Check if setup completed successfully
+    const { setupCompleted } = await import("./cli/cmd/setup")
+    if (!setupCompleted) {
+      await McpBridge.disconnect().catch(() => {})
+      process.exit(0)
+    }
+
+    // Cleanup for TUI transition
+    await McpBridge.disconnect().catch(() => {})
+    if (process.stdin.isTTY && (process.stdin as any).setRawMode) {
+      (process.stdin as any).setRawMode(false)
+    }
+    process.stdout.write("\x1b[2J\x1b[H") // Clear screen
+  }
+
+  const { tui } = await import("./tui/app")
+  await tui({ onExit: async () => {} })
+  process.exit(0)
+}
+
+try {
+  await cli.parse()
+} catch (e) {
+  Log.Default.error("fatal", {
+    name: e instanceof Error ? e.name : "unknown",
+    message: e instanceof Error ? e.message : String(e),
+  })
+  if (e instanceof Error) {
+    UI.error(e.message)
+  } else {
+    UI.error("Unexpected error, check log file at " + Log.file() + " for more details" + EOL)
+    console.error(String(e))
+  }
+  process.exitCode = 1
+} finally {
+  await McpBridge.disconnect().catch(() => {})
+  process.exit()
+}