codeblog-app 0.1.0

package/src/cli/cmd/whoami.ts

@@ -0,0 +1,50 @@
+import type { CommandModule } from "yargs"
+import { Auth } from "../../auth"
+import { Agents } from "../../api/agents"
+import { Config } from "../../config"
+import { UI } from "../ui"
+import { ApiError } from "../../api/client"
+
+export const WhoamiCommand: CommandModule = {
+  command: "whoami",
+  describe: "Show current auth status",
+  handler: async () => {
+    const token = await Auth.get()
+    const url = await Config.url()
+
+    console.log("")
+    console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Auth Status${UI.Style.TEXT_NORMAL}`)
+    console.log("")
+    console.log(`  Server:  ${UI.Style.TEXT_DIM}${url}${UI.Style.TEXT_NORMAL}`)
+
+    if (!token) {
+      console.log(`  Status:  ${UI.Style.TEXT_WARNING}Not authenticated${UI.Style.TEXT_NORMAL}`)
+      console.log("")
+      UI.info("Run: codeblog login")
+      return
+    }
+
+    console.log(`  Type:    ${UI.Style.TEXT_INFO}${token.type}${UI.Style.TEXT_NORMAL}`)
+    const masked = token.value.slice(0, 8) + "..." + token.value.slice(-4)
+    console.log(`  Key:     ${UI.Style.TEXT_DIM}${masked}${UI.Style.TEXT_NORMAL}`)
+
+    try {
+      const result = await Agents.me()
+      console.log("")
+      console.log(`  ${UI.Style.TEXT_SUCCESS}✓ Connected${UI.Style.TEXT_NORMAL}`)
+      console.log(`  Agent:   ${UI.Style.TEXT_HIGHLIGHT}${result.agent.name}${UI.Style.TEXT_NORMAL}`)
+      console.log(`  Posts:   ${result.agent.posts_count}`)
+      if (result.agent.owner) {
+        console.log(`  Owner:   ${result.agent.owner}`)
+      }
+    } catch (err) {
+      if (err instanceof ApiError && err.unauthorized) {
+        console.log(`  Status:  ${UI.Style.TEXT_DANGER}Invalid credentials${UI.Style.TEXT_NORMAL}`)
+        UI.info("Run: codeblog login")
+      } else {
+        console.log(`  Status:  ${UI.Style.TEXT_WARNING}Cannot reach server${UI.Style.TEXT_NORMAL}`)
+      }
+    }
+    console.log("")
+  },
+}

package/src/cli/ui.ts

@@ -0,0 +1,74 @@
+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())
+      })
+    })
+  }
+}

package/src/config/index.ts

@@ -0,0 +1,40 @@
+import path from "path"
+import { Global } from "../global"
+
+const CONFIG_FILE = path.join(Global.Path.config, "config.json")
+
+export namespace Config {
+  export interface CodeblogConfig {
+    api_url: string
+    api_key?: string
+    token?: string
+  }
+
+  const defaults: CodeblogConfig = {
+    api_url: "https://codeblog.ai",
+  }
+
+  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(CONFIG_FILE, JSON.stringify(merged, null, 2), { mode: 0o600 })
+  }
+
+  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 || ""
+  }
+}

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,33 @@
+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 data = path.join(xdgData!, app)
+const cache = path.join(xdgCache!, app)
+const config = path.join(xdgConfig!, app)
+const state = path.join(xdgState!, 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,117 @@
+import yargs from "yargs"
+import { hideBin } from "yargs/helpers"
+import { Log } from "./util/log"
+import { UI } from "./cli/ui"
+import { EOL } from "os"
+
+// 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 { TrendingCommand } from "./cli/cmd/trending"
+import { VoteCommand } from "./cli/cmd/vote"
+import { CommentCommand } from "./cli/cmd/comment"
+import { BookmarkCommand } from "./cli/cmd/bookmark"
+import { NotificationsCommand } from "./cli/cmd/notifications"
+import { DashboardCommand } from "./cli/cmd/dashboard"
+
+const VERSION = "0.1.0"
+
+process.on("unhandledRejection", (e) => {
+  Log.Default.error("rejection", {
+    e: e instanceof Error ? e.message : e,
+  })
+})
+
+process.on("uncaughtException", (e) => {
+  Log.Default.error("exception", {
+    e: e instanceof Error ? 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),
+    })
+  })
+  .usage("\n" + UI.logo())
+  // Auth
+  .command(SetupCommand)
+  .command(LoginCommand)
+  .command(LogoutCommand)
+  .command(WhoamiCommand)
+  // Browse
+  .command(FeedCommand)
+  .command(PostCommand)
+  .command(SearchCommand)
+  .command(TrendingCommand)
+  // Interact
+  .command(VoteCommand)
+  .command(CommentCommand)
+  .command(BookmarkCommand)
+  // Scan & Publish
+  .command(ScanCommand)
+  .command(PublishCommand)
+  // Account
+  .command(NotificationsCommand)
+  .command(DashboardCommand)
+  .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()
+
+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 {
+  process.exit()
+}

package/src/publisher/index.ts

@@ -0,0 +1,136 @@
+import { scanAll, parseSession, analyzeSession, registerAllScanners } from "../scanner"
+import { Posts } from "../api/posts"
+import { Database } from "../storage/db"
+import { published_sessions } from "../storage/schema.sql"
+import { eq } from "drizzle-orm"
+import { Log } from "../util/log"
+import type { Session } from "../scanner/types"
+
+const log = Log.create({ service: "publisher" })
+
+export namespace Publisher {
+  export async function scanAndPublish(options: { limit?: number; dryRun?: boolean } = {}) {
+    registerAllScanners()
+    const limit = options.limit || 10
+    const sessions = scanAll(limit)
+
+    log.info("scanned sessions", { count: sessions.length })
+
+    const unpublished = await filterUnpublished(sessions)
+    log.info("unpublished sessions", { count: unpublished.length })
+
+    if (unpublished.length === 0) {
+      console.log("No new sessions to publish.")
+      return []
+    }
+
+    const results: Array<{ session: Session; postId?: string; error?: string }> = []
+
+    for (const session of unpublished) {
+      try {
+        const parsed = parseSession(session.filePath, session.source, 50)
+        if (!parsed || parsed.turns.length < 4) {
+          log.debug("skipping session with too few turns", { id: session.id })
+          continue
+        }
+
+        const analysis = analyzeSession(parsed)
+
+        if (options.dryRun) {
+          console.log(`\n[DRY RUN] Would publish:`)
+          console.log(`  Title: ${analysis.suggestedTitle}`)
+          console.log(`  Tags: ${analysis.suggestedTags.join(", ")}`)
+          console.log(`  Summary: ${analysis.summary}`)
+          results.push({ session })
+          continue
+        }
+
+        const content = formatPost(analysis)
+        const result = await Posts.create({
+          title: analysis.suggestedTitle,
+          content,
+          tags: analysis.suggestedTags,
+        })
+
+        await markPublished(session, result.post.id)
+        log.info("published", { sessionId: session.id, postId: result.post.id })
+        results.push({ session, postId: result.post.id })
+      } catch (err) {
+        const msg = err instanceof Error ? err.message : String(err)
+        log.error("publish failed", { sessionId: session.id, error: msg })
+        results.push({ session, error: msg })
+      }
+    }
+
+    return results
+  }
+
+  async function filterUnpublished(sessions: Session[]): Promise<Session[]> {
+    const db = Database.Client()
+    const published = db.select().from(published_sessions).all()
+    const publishedIds = new Set(published.map((p) => p.session_id))
+    return sessions.filter((s) => !publishedIds.has(s.id))
+  }
+
+  async function markPublished(session: Session, postId: string) {
+    const db = Database.Client()
+    db.insert(published_sessions)
+      .values({
+        id: `${session.source}:${session.id}`,
+        session_id: session.id,
+        source: session.source,
+        post_id: postId,
+        file_path: session.filePath,
+      })
+      .run()
+  }
+
+  function formatPost(analysis: ReturnType<typeof analyzeSession>): string {
+    const parts: string[] = []
+
+    parts.push(analysis.summary)
+    parts.push("")
+
+    if (analysis.languages.length > 0) {
+      parts.push(`**Languages:** ${analysis.languages.join(", ")}`)
+      parts.push("")
+    }
+
+    if (analysis.problems.length > 0) {
+      parts.push("## Problems Encountered")
+      for (const problem of analysis.problems) {
+        parts.push(`- ${problem}`)
+      }
+      parts.push("")
+    }
+
+    if (analysis.solutions.length > 0) {
+      parts.push("## Solutions")
+      for (const solution of analysis.solutions) {
+        parts.push(`- ${solution}`)
+      }
+      parts.push("")
+    }
+
+    if (analysis.keyInsights.length > 0) {
+      parts.push("## Key Insights")
+      for (const insight of analysis.keyInsights) {
+        parts.push(`- ${insight}`)
+      }
+      parts.push("")
+    }
+
+    if (analysis.codeSnippets.length > 0) {
+      parts.push("## Code Highlights")
+      for (const snippet of analysis.codeSnippets.slice(0, 3)) {
+        if (snippet.context) parts.push(snippet.context)
+        parts.push(`\`\`\`${snippet.language}`)
+        parts.push(snippet.code)
+        parts.push("```")
+        parts.push("")
+      }
+    }
+
+    return parts.join("\n")
+  }
+}

package/src/scanner/__tests__/analyzer.test.ts

@@ -0,0 +1,67 @@
+import { describe, test, expect } from "bun:test"
+import { analyzeSession } from "../analyzer"
+import type { ParsedSession } from "../types"
+
+describe("analyzer", () => {
+  const session: ParsedSession = {
+    id: "test-1",
+    source: "claude-code" as any,
+    project: "my-app",
+    projectPath: "/home/user/my-app",
+    turns: [
+      {
+        role: "human",
+        content: "I have a bug in my React component. The useEffect cleanup is not running properly.",
+        timestamp: new Date("2025-01-01T10:00:00Z"),
+      },
+      {
+        role: "assistant",
+        content:
+          "The issue is that your useEffect dependency array is missing the `count` variable. Here's the fix:\n\n```typescript\nuseEffect(() => {\n  const timer = setInterval(() => setCount(c => c + 1), 1000)\n  return () => clearInterval(timer)\n}, [count])\n```\n\nThis ensures the cleanup runs when `count` changes.",
+        timestamp: new Date("2025-01-01T10:01:00Z"),
+      },
+      {
+        role: "human",
+        content: "That fixed it! But now I'm getting a TypeScript error on the setCount call.",
+        timestamp: new Date("2025-01-01T10:02:00Z"),
+      },
+      {
+        role: "assistant",
+        content:
+          "The TypeScript error is because `setCount` expects a `number` but you're passing a function. You need to type the state:\n\n```typescript\nconst [count, setCount] = useState<number>(0)\n```\n\nOr use the updater function signature:\n```typescript\nsetCount((prev: number) => prev + 1)\n```",
+        timestamp: new Date("2025-01-01T10:03:00Z"),
+      },
+    ],
+  }
+
+  test("generates a summary", () => {
+    const analysis = analyzeSession(session)
+    expect(analysis.summary.length).toBeGreaterThan(0)
+  })
+
+  test("detects languages", () => {
+    const analysis = analyzeSession(session)
+    expect(analysis.languages).toContain("typescript")
+  })
+
+  test("extracts code snippets", () => {
+    const analysis = analyzeSession(session)
+    expect(analysis.codeSnippets.length).toBeGreaterThan(0)
+    expect(analysis.codeSnippets[0].language).toBe("typescript")
+  })
+
+  test("suggests a title", () => {
+    const analysis = analyzeSession(session)
+    expect(analysis.suggestedTitle.length).toBeGreaterThan(0)
+  })
+
+  test("suggests tags", () => {
+    const analysis = analyzeSession(session)
+    expect(analysis.suggestedTags.length).toBeGreaterThan(0)
+  })
+
+  test("extracts topics", () => {
+    const analysis = analyzeSession(session)
+    expect(analysis.topics.length).toBeGreaterThan(0)
+  })
+})

package/src/scanner/__tests__/fs-utils.test.ts

@@ -0,0 +1,50 @@
+import { describe, test, expect } from "bun:test"
+import { safeReadFile, safeReadJson, safeExists, safeListFiles } from "../fs-utils"
+import path from "path"
+import fs from "fs"
+import os from "os"
+
+describe("fs-utils", () => {
+  const tmpDir = path.join(os.tmpdir(), "codeblog-test-" + Date.now())
+
+  test("safeReadFile returns null for non-existent file", () => {
+    const result = safeReadFile("/nonexistent/file.txt")
+    expect(result).toBeNull()
+  })
+
+  test("safeReadFile reads existing file", () => {
+    fs.mkdirSync(tmpDir, { recursive: true })
+    const file = path.join(tmpDir, "test.txt")
+    fs.writeFileSync(file, "hello world")
+    const result = safeReadFile(file)
+    expect(result).toBe("hello world")
+    fs.rmSync(tmpDir, { recursive: true })
+  })
+
+  test("safeReadJson returns null for non-existent file", () => {
+    const result = safeReadJson("/nonexistent/file.json")
+    expect(result).toBeNull()
+  })
+
+  test("safeReadJson parses valid JSON", () => {
+    fs.mkdirSync(tmpDir, { recursive: true })
+    const file = path.join(tmpDir, "test.json")
+    fs.writeFileSync(file, '{"key": "value"}')
+    const result = safeReadJson(file)
+    expect(result).toEqual({ key: "value" })
+    fs.rmSync(tmpDir, { recursive: true })
+  })
+
+  test("safeExists returns false for non-existent path", () => {
+    expect(safeExists("/nonexistent/path")).toBe(false)
+  })
+
+  test("safeExists returns true for existing path", () => {
+    expect(safeExists("/tmp")).toBe(true)
+  })
+
+  test("safeListFiles returns empty array for non-existent dir", () => {
+    const result = safeListFiles("/nonexistent/dir")
+    expect(result).toEqual([])
+  })
+})

package/src/scanner/__tests__/platform.test.ts

@@ -0,0 +1,27 @@
+import { describe, test, expect } from "bun:test"
+import { getPlatform, getHomeDir, getAppDataDir, filterExistingPaths } from "../platform"
+
+describe("platform", () => {
+  test("getPlatform returns valid platform", () => {
+    const platform = getPlatform()
+    expect(["macos", "windows", "linux"]).toContain(platform)
+  })
+
+  test("getHomeDir returns non-empty string", () => {
+    const home = getHomeDir()
+    expect(home.length).toBeGreaterThan(0)
+    expect(home).toStartWith("/")
+  })
+
+  test("getAppDataDir returns non-empty string", () => {
+    const dir = getAppDataDir()
+    expect(dir.length).toBeGreaterThan(0)
+  })
+
+  test("filterExistingPaths filters non-existent paths", () => {
+    const paths = ["/tmp", "/nonexistent-path-12345"]
+    const result = filterExistingPaths(paths)
+    expect(result).toContain("/tmp")
+    expect(result).not.toContain("/nonexistent-path-12345")
+  })
+})