codeblog-app 2.8.2 → 2.9.5

package/src/cli/cmd/companion.ts

@@ -0,0 +1,393 @@
+import type { CommandModule } from "yargs"
+import { AIChat } from "../../ai/chat"
+import { AIProvider } from "../../ai/provider"
+import { Config } from "../../config"
+import { Global } from "../../global"
+import { UI } from "../ui"
+import * as fs from "fs/promises"
+import * as fsSync from "fs"
+import * as path from "path"
+import * as os from "os"
+import { execSync, spawn } from "child_process"
+
+const COMPANION_SCAN_PROMPT = `You are a background coding companion running a silent scan. Your job is to find IDE sessions with insights worth saving as draft blog posts.
+
+Follow these steps:
+
+1. Call scan_sessions with limit=20 to get recent sessions.
+
+2. For each session, check if it's worth analyzing:
+   - Skip sessions with fewer than 10 messages (too short)
+   - Skip sessions where analyzed=true
+   - Focus on sessions modified in the last 48 hours
+
+3. Pick up to 3 candidate sessions. For each, call analyze_session to understand the content.
+
+4. For each analyzed session, decide if it contains a compelling insight:
+   WORTH SAVING AS DRAFT if ANY of:
+   - A non-obvious bug was found and solved (not just a typo)
+   - A new technique, pattern, or API was discovered
+   - An architectural decision was made with interesting trade-offs
+   - A genuine "TIL" moment that other developers would find valuable
+   - A performance insight with measurable impact
+
+   NOT WORTH SAVING if:
+   - Pure mechanical work (renaming, formatting, minor config tweaks)
+   - Session is incomplete or inconclusive
+   - Trivial syntax or typo fixes
+   - Generic "I added a feature" with no deeper insight
+
+5. For sessions worth saving, call create_draft with:
+   - A specific, compelling title (e.g. "Why Prisma silently drops your WHERE clause when you pass undefined" NOT "Debugging session")
+   - Content written in first person as the AI agent: "I noticed...", "We discovered...", "The insight here is..."
+   - Category: 'til' for discoveries, 'bugs' for bug stories, 'general' for architectural insights
+   - Tags from the actual languages/frameworks used
+   - source_session set to the exact session path from scan_sessions
+
+IMPORTANT: You are running silently in the background. Output only a brief final summary line, e.g.:
+"Companion scan complete: 8 sessions checked, 1 draft saved."
+Do NOT output verbose step-by-step commentary.`
+
+function getLaunchAgentPath(): string {
+  return path.join(os.homedir(), "Library", "LaunchAgents", "ai.codeblog.companion.plist")
+}
+
+function getSystemdServicePath(): string {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config")
+  return path.join(configHome, "systemd", "user", "codeblog-companion.service")
+}
+
+function getSystemdTimerPath(): string {
+  const configHome = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), ".config")
+  return path.join(configHome, "systemd", "user", "codeblog-companion.timer")
+}
+
+function getCompanionLogPath(): string {
+  return path.join(Global.Path.log, "companion.log")
+}
+
+function getCompanionStatePath(): string {
+  return path.join(Global.Path.state, "companion.json")
+}
+
+interface CompanionState {
+  lastRunAt?: string
+  lastDraftsCreated?: number
+  lastSessionsScanned?: number
+  installMethod?: "launchd" | "systemd"
+}
+
+async function readState(): Promise<CompanionState> {
+  try {
+    const raw = await fs.readFile(getCompanionStatePath(), "utf-8")
+    return JSON.parse(raw)
+  } catch {
+    return {}
+  }
+}
+
+async function writeState(state: Partial<CompanionState>): Promise<void> {
+  const current = await readState()
+  const merged = { ...current, ...state }
+  await fs.writeFile(getCompanionStatePath(), JSON.stringify(merged, null, 2))
+}
+
+function getCodeblogBinPath(): string {
+  // Use the actual binary path (resolved from process.argv[1] if available)
+  const argv1 = process.argv[1]
+  if (argv1 && fsSync.existsSync(argv1)) return argv1
+  // Fallback: search PATH
+  try {
+    return execSync("which codeblog", { encoding: "utf-8" }).trim()
+  } catch {
+    return "codeblog"
+  }
+}
+
+async function installMacOS(intervalMinutes: number): Promise<void> {
+  const plistPath = getLaunchAgentPath()
+  const binPath = getCodeblogBinPath()
+  const logPath = getCompanionLogPath()
+  const intervalSeconds = intervalMinutes * 60
+
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>ai.codeblog.companion</string>
+  <key>ProgramArguments</key>
+  <array>
+    <string>${binPath}</string>
+    <string>companion</string>
+    <string>run</string>
+  </array>
+  <key>StartInterval</key>
+  <integer>${intervalSeconds}</integer>
+  <key>RunAtLoad</key>
+  <false/>
+  <key>StandardOutPath</key>
+  <string>${logPath}</string>
+  <key>StandardErrorPath</key>
+  <string>${logPath}</string>
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>/usr/local/bin:/usr/bin:/bin:/opt/homebrew/bin</string>
+    <key>HOME</key>
+    <string>${os.homedir()}</string>
+  </dict>
+</dict>
+</plist>`
+
+  await fs.mkdir(path.dirname(plistPath), { recursive: true })
+  await fs.writeFile(plistPath, plistContent)
+
+  // Unload first (if already loaded), then load
+  try { execSync(`launchctl unload "${plistPath}" 2>/dev/null`, { stdio: "ignore" }) } catch {}
+  execSync(`launchctl load "${plistPath}"`)
+}
+
+async function installLinux(intervalMinutes: number): Promise<void> {
+  const servicePath = getSystemdServicePath()
+  const timerPath = getSystemdTimerPath()
+  const binPath = getCodeblogBinPath()
+  const logPath = getCompanionLogPath()
+
+  const serviceContent = `[Unit]
+Description=CodeBlog Companion - background coding session scanner
+After=network.target
+
+[Service]
+Type=oneshot
+ExecStart=${binPath} companion run
+StandardOutput=append:${logPath}
+StandardError=append:${logPath}
+Environment=HOME=${os.homedir()}
+
+[Install]
+WantedBy=default.target`
+
+  const timerContent = `[Unit]
+Description=CodeBlog Companion timer - runs every ${intervalMinutes} minutes
+
+[Timer]
+OnBootSec=5min
+OnUnitActiveSec=${intervalMinutes}min
+Unit=codeblog-companion.service
+
+[Install]
+WantedBy=timers.target`
+
+  await fs.mkdir(path.dirname(servicePath), { recursive: true })
+  await fs.writeFile(servicePath, serviceContent)
+  await fs.writeFile(timerPath, timerContent)
+
+  execSync("systemctl --user daemon-reload")
+  execSync("systemctl --user enable --now codeblog-companion.timer")
+}
+
+async function stopMacOS(): Promise<void> {
+  const plistPath = getLaunchAgentPath()
+  try {
+    execSync(`launchctl unload "${plistPath}"`)
+    await fs.unlink(plistPath)
+  } catch (e) {
+    throw new Error(`Failed to stop launchd job: ${e}`)
+  }
+}
+
+async function stopLinux(): Promise<void> {
+  try {
+    execSync("systemctl --user disable --now codeblog-companion.timer")
+    await fs.unlink(getSystemdServicePath()).catch(() => {})
+    await fs.unlink(getSystemdTimerPath()).catch(() => {})
+    execSync("systemctl --user daemon-reload")
+  } catch (e) {
+    throw new Error(`Failed to stop systemd timer: ${e}`)
+  }
+}
+
+function isRunningMacOS(): boolean {
+  try {
+    const output = execSync("launchctl list ai.codeblog.companion 2>/dev/null", { encoding: "utf-8" })
+    return output.includes("ai.codeblog.companion")
+  } catch {
+    return false
+  }
+}
+
+function isRunningLinux(): boolean {
+  try {
+    const output = execSync("systemctl --user is-active codeblog-companion.timer 2>/dev/null", {
+      encoding: "utf-8",
+    }).trim()
+    return output === "active"
+  } catch {
+    return false
+  }
+}
+
+const CompanionStartCommand: CommandModule = {
+  command: "start",
+  describe: "Install and start the background companion daemon",
+  builder: (yargs) =>
+    yargs.option("interval", {
+      describe: "Scan interval in minutes (default: 120)",
+      type: "number",
+      default: 120,
+    }),
+  handler: async (args) => {
+    const interval = args.interval as number
+    const platform = os.platform()
+
+    UI.info(`Installing CodeBlog Companion (every ${interval} min)...`)
+
+    try {
+      if (platform === "darwin") {
+        await installMacOS(interval)
+        await writeState({ installMethod: "launchd" })
+        UI.success(`Companion installed via launchd. It will scan your IDE sessions every ${interval} minutes.`)
+        UI.info(`Log file: ${getCompanionLogPath()}`)
+      } else if (platform === "linux") {
+        await installLinux(interval)
+        await writeState({ installMethod: "systemd" })
+        UI.success(`Companion installed via systemd. It will scan your IDE sessions every ${interval} minutes.`)
+        UI.info(`Log file: ${getCompanionLogPath()}`)
+      } else {
+        UI.error(`Unsupported platform: ${platform}. Only macOS and Linux are supported.`)
+        process.exitCode = 1
+      }
+    } catch (err) {
+      UI.error(`Failed to install companion: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}
+
+const CompanionStopCommand: CommandModule = {
+  command: "stop",
+  describe: "Stop and uninstall the background companion daemon",
+  handler: async () => {
+    const platform = os.platform()
+
+    try {
+      if (platform === "darwin") {
+        await stopMacOS()
+        UI.success("Companion stopped and removed.")
+      } else if (platform === "linux") {
+        await stopLinux()
+        UI.success("Companion stopped and removed.")
+      } else {
+        UI.error(`Unsupported platform: ${platform}.`)
+        process.exitCode = 1
+        return
+      }
+      await writeState({ installMethod: undefined })
+    } catch (err) {
+      UI.error(`Failed to stop companion: ${err instanceof Error ? err.message : String(err)}`)
+      process.exitCode = 1
+    }
+  },
+}
+
+const CompanionStatusCommand: CommandModule = {
+  command: "status",
+  describe: "Show companion daemon status and recent activity",
+  handler: async () => {
+    const platform = os.platform()
+    const state = await readState()
+
+    let isRunning = false
+    if (platform === "darwin") {
+      isRunning = isRunningMacOS()
+    } else if (platform === "linux") {
+      isRunning = isRunningLinux()
+    }
+
+    console.log("")
+    if (isRunning) {
+      UI.success("Companion is RUNNING")
+    } else {
+      UI.warn("Companion is NOT running. Use 'codeblog companion start' to enable it.")
+    }
+
+    if (state.lastRunAt) {
+      console.log(`  Last run:     ${new Date(state.lastRunAt).toLocaleString()}`)
+    }
+    if (state.lastSessionsScanned !== undefined) {
+      console.log(`  Last scan:    ${state.lastSessionsScanned} sessions checked`)
+    }
+    if (state.lastDraftsCreated !== undefined) {
+      console.log(`  Last result:  ${state.lastDraftsCreated} draft(s) created`)
+    }
+    if (isRunning) {
+      const logPath = getCompanionLogPath()
+      console.log(`  Log file:     ${logPath}`)
+    }
+    console.log("")
+  },
+}
+
+const CompanionRunCommand: CommandModule = {
+  command: "run",
+  describe: "Run one companion scan immediately (also called by the daemon)",
+  handler: async () => {
+    const hasKey = await AIProvider.hasAnyKey()
+    if (!hasKey) {
+      // Silent failure when running as daemon (no terminal)
+      process.exitCode = 1
+      return
+    }
+
+    const cfg = await Config.load()
+    const minMessages = cfg.companion?.minSessionMessages ?? 10
+
+    const prompt = `${COMPANION_SCAN_PROMPT}
+
+Additional context: skip sessions with fewer than ${minMessages} messages.`
+
+    // Record start time
+    const startTime = new Date().toISOString()
+
+    let summaryLine = ""
+    await AIChat.stream(
+      [{ role: "user", content: prompt }],
+      {
+        onToken: (token) => {
+          summaryLine += token
+          // When running as daemon, write to stdout (captured by launchd/systemd to log)
+          process.stdout.write(token)
+        },
+        onFinish: () => {
+          process.stdout.write("\n")
+        },
+        onError: (err) => {
+          process.stderr.write(`Companion scan error: ${err.message}\n`)
+        },
+      },
+    )
+
+    // Parse summary line for state update (best-effort)
+    const draftsMatch = summaryLine.match(/(\d+)\s+draft/i)
+    const sessionsMatch = summaryLine.match(/(\d+)\s+session/i)
+    await writeState({
+      lastRunAt: startTime,
+      lastDraftsCreated: draftsMatch ? parseInt(draftsMatch[1]!) : 0,
+      lastSessionsScanned: sessionsMatch ? parseInt(sessionsMatch[1]!) : 0,
+    })
+  },
+}
+
+export const CompanionCommand: CommandModule = {
+  command: "companion <subcommand>",
+  describe: "Manage the background AI coding companion",
+  builder: (yargs) =>
+    yargs
+      .command(CompanionStartCommand)
+      .command(CompanionStopCommand)
+      .command(CompanionStatusCommand)
+      .command(CompanionRunCommand)
+      .demandCommand(1, "Specify a subcommand: start, stop, status, run"),
+  handler: () => {},
+}

package/src/cli/cmd/config.ts

@@ -86,12 +86,12 @@ export const ConfigCommand: CommandModule = {
 
       if (args.provider && (args.apiKey || args.baseUrl)) {
         const cfg = await Config.load()
-        const providers = cfg.providers || {}
+        const providers = cfg.cli?.providers || {}
         const existing = providers[args.provider as string] || {} as Config.ProviderConfig
-        if (args.apiKey) existing.api_key = args.apiKey as string
-        if (args.baseUrl) existing.base_url = args.baseUrl as string
+        if (args.apiKey) existing.apiKey = args.apiKey as string
+        if (args.baseUrl) existing.baseUrl = args.baseUrl as string
         providers[args.provider as string] = existing
-        await Config.save({ providers })
+        await Config.save({ cli: { providers } })
         const parts: string[] = []
         if (args.apiKey) parts.push("API key")
         if (args.baseUrl) parts.push(`base URL (${args.baseUrl})`)
@@ -100,19 +100,19 @@ export const ConfigCommand: CommandModule = {
       }
 
       if (args.model) {
-        await Config.save({ model: args.model as string })
+        await Config.save({ cli: { model: args.model as string } })
         UI.success(`Default model set to ${args.model}`)
         return
       }
 
       if (args.url) {
-        await Config.save({ api_url: args.url as string })
+        await Config.save({ serverUrl: args.url as string })
         UI.success(`Server URL set to ${args.url}`)
         return
       }
 
       if (args.language) {
-        await Config.save({ default_language: args.language as string })
+        await Config.save({ cli: { defaultLanguage: args.language as string } })
         UI.success(`Default language set to ${args.language}`)
         return
       }
@@ -121,22 +121,22 @@ export const ConfigCommand: CommandModule = {
       const cfg = await Config.load()
       const { resolveModelFromConfig } = await import("../../ai/models")
       const model = resolveModelFromConfig(cfg) || AIProvider.DEFAULT_MODEL
-      const providers = cfg.providers || {}
+      const providers = cfg.cli?.providers || {}
 
       console.log("")
       console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}Current Config${UI.Style.TEXT_NORMAL}`)
       console.log(`  ${UI.Style.TEXT_DIM}${Config.filepath}${UI.Style.TEXT_NORMAL}`)
       console.log("")
       console.log(`  Model:     ${UI.Style.TEXT_HIGHLIGHT}${model}${UI.Style.TEXT_NORMAL}`)
-      console.log(`  API URL:   ${cfg.api_url || "https://codeblog.ai"}`)
-      console.log(`  Language:  ${cfg.default_language || `${UI.Style.TEXT_DIM}(server default)${UI.Style.TEXT_NORMAL}`}`)
+      console.log(`  API URL:   ${cfg.serverUrl || "https://codeblog.ai"}`)
+      console.log(`  Language:  ${cfg.cli?.defaultLanguage || `${UI.Style.TEXT_DIM}(server default)${UI.Style.TEXT_NORMAL}`}`)
       console.log("")
 
       if (Object.keys(providers).length > 0) {
         console.log(`  ${UI.Style.TEXT_NORMAL_BOLD}AI Providers${UI.Style.TEXT_NORMAL}`)
         for (const [id, p] of Object.entries(providers)) {
-          const masked = p.api_key ? p.api_key.slice(0, 8) + "..." : "not set"
-          const url = p.base_url ? ` → ${p.base_url}` : ""
+          const masked = p.apiKey ? p.apiKey.slice(0, 8) + "..." : "not set"
+          const url = p.baseUrl ? ` → ${p.baseUrl}` : ""
           console.log(`    ${UI.Style.TEXT_SUCCESS}✓${UI.Style.TEXT_NORMAL} ${id}: ${UI.Style.TEXT_DIM}${masked}${url}${UI.Style.TEXT_NORMAL}`)
         }
       } else {

package/src/cli/cmd/login.ts

@@ -1,7 +1,6 @@
 import type { CommandModule } from "yargs"
 import { OAuth } from "../../auth/oauth"
 import { Auth } from "../../auth"
-import { McpBridge } from "../../mcp/client"
 import { UI } from "../ui"
 
 export const LoginCommand: CommandModule = {
@@ -23,12 +22,6 @@ export const LoginCommand: CommandModule = {
     if (args.key) {
       const key = args.key as string
       await Auth.set({ type: "apikey", value: key })
-      // Sync API key to MCP config (~/.codeblog/config.json)
-      try {
-        await McpBridge.callTool("codeblog_setup", { api_key: key })
-      } catch {
-        // Non-fatal: MCP sync failed but CLI auth is saved
-      }
       UI.success("Logged in with API key")
       return
     }

package/src/cli/cmd/logout.ts

@@ -1,14 +1,16 @@
 import type { CommandModule } from "yargs"
 import { Auth } from "../../auth"
-import { Config } from "../../config"
 import { UI } from "../ui"
 
 export const LogoutCommand: CommandModule = {
   command: "logout",
   describe: "Logout from CodeBlog",
   handler: async () => {
+    const { McpBridge } = await import("../../mcp/client")
+    const { clearChatToolsCache } = await import("../../ai/tools")
     await Auth.remove()
-    await Config.clearActiveAgent()
+    await McpBridge.disconnect()
+    clearChatToolsCache()
     UI.success("Logged out successfully")
   },
 }

package/src/cli/cmd/setup.ts

@@ -356,7 +356,7 @@ function isOfficialOpenAIBase(baseURL: string): boolean {
   }
 }
 
-async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: string): Promise<{ ok: boolean; detail: string; detectedApi?: Config.ModelApi }> {
+async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: string): Promise<{ ok: boolean; detail: string; detectedApi?: Config.ApiType }> {
   try {
     if (choice.api === "anthropic") {
       const clean = baseURL.replace(/\/+$/, "")
@@ -383,7 +383,7 @@ async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: stri
     const detected = await probe(baseURL, key)
     if (detected === "anthropic") return { ok: true, detail: "Detected Anthropic API format", detectedApi: "anthropic" }
     if (detected === "openai") {
-      const detectedApi: Config.ModelApi =
+      const detectedApi: Config.ApiType =
         choice.providerID === "openai" && isOfficialOpenAIBase(baseURL)
           ? "openai"
           : "openai-compatible"
@@ -392,7 +392,7 @@ async function verifyEndpoint(choice: ProviderChoice, baseURL: string, key: stri
 
     const models = await fetchOpenAIModels(baseURL, key)
     if (models.length > 0) {
-      const detectedApi: Config.ModelApi =
+      const detectedApi: Config.ApiType =
         choice.providerID === "openai" && isOfficialOpenAIBase(baseURL)
           ? "openai"
           : "openai-compatible"
@@ -501,18 +501,20 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
 
       const proxyURL = `${(await Config.url()).replace(/\/+$/, "")}/api/v1/ai-credit/chat`
       const cfg = await Config.load()
-      const providers = cfg.providers || {}
+      const providers = cfg.cli?.providers || {}
       providers["codeblog"] = {
-        api_key: "proxy",
-        base_url: proxyURL,
-        api: "openai-compatible",
-        compat_profile: "openai-compatible",
+        apiKey: "proxy",
+        baseUrl: proxyURL,
+        apiType: "openai-compatible",
+        compatProfile: "openai-compatible",
       }
 
       await Config.save({
-        providers,
-        default_provider: "codeblog",
-        model: `codeblog/${balance.model}`,
+        cli: {
+          providers,
+          defaultProvider: "codeblog",
+          model: `codeblog/${balance.model}`,
+        },
       })
 
       UI.success(`AI configured: CodeBlog Credit (${balance.model})`)
@@ -567,7 +569,7 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
   }
 
   let verified = false
-  let detectedApi: Config.ModelApi | undefined
+  let detectedApi: Config.ApiType | undefined
 
   while (!verified) {
     await shimmerLine("Verifying endpoint...", 900)
@@ -589,17 +591,17 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
     return
   }
   const cfg = await Config.load()
-  const providers = cfg.providers || {}
+  const providers = cfg.cli?.providers || {}
   const resolvedApi = detectedApi || provider.api
   const resolvedCompat = provider.providerID === "openai-compatible" && resolvedApi === "openai"
     ? "openai-compatible"
     : resolvedApi
   const providerConfig: Config.ProviderConfig = {
-    api_key: key,
-    api: resolvedApi,
-    compat_profile: resolvedCompat,
+    apiKey: key,
+    apiType: resolvedApi,
+    compatProfile: resolvedCompat,
   }
-  if (baseURL) providerConfig.base_url = baseURL
+  if (baseURL) providerConfig.baseUrl = baseURL
   providers[provider.providerID] = providerConfig
 
   const model = provider.providerID === "openai-compatible" && !selectedModel.includes("/")
@@ -607,9 +609,11 @@ export async function runAISetupWizard(source: "setup" | "command" = "command"):
     : selectedModel
 
   await Config.save({
-    providers,
-    default_provider: provider.providerID,
-    model,
+    cli: {
+      providers,
+      defaultProvider: provider.providerID,
+      model,
+    },
   })
 
   UI.success(`AI configured: ${provider.name} (${model})`)
@@ -763,11 +767,6 @@ async function agentSelectionPrompt(): Promise<void> {
         await Auth.set({ type: "apikey", value: switchData.agent.api_key, username: auth.username })
         await Config.saveActiveAgent(switchData.agent.name, auth.username)
 
-        // Sync to MCP config
-        try {
-          await McpBridge.callTool("codeblog_setup", { api_key: switchData.agent.api_key })
-        } catch {}
-
         UI.success(`Active agent: ${switchData.agent.name}`)
       } else {
         UI.error("Failed to switch agent. You can switch later with: codeblog agent switch")
@@ -864,11 +863,6 @@ async function agentCreationWizard(): Promise<void> {
     await Auth.set({ type: "apikey", value: result.api_key, username: auth?.username })
     await Config.saveActiveAgent(result.name, auth?.username)
 
-    // Sync to MCP config
-    try {
-      await McpBridge.callTool("codeblog_setup", { api_key: result.api_key })
-    } catch {}
-
     console.log("")
     UI.success(`Your agent "${emoji} ${name}" is ready! It'll represent you on CodeBlog.`)
   } catch (err) {