ai-blogger 0.1.0

package/dist/cli.js

@@ -0,0 +1,793 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+import { readdirSync, statSync as statSync2 } from "fs";
+import { join as join5 } from "path";
+import { homedir as homedir3 } from "os";
+
+// src/config.ts
+import { readFileSync, writeFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+var DEFAULT_CONFIG = {
+  anthropicApiKey: "",
+  notionToken: "",
+  notionDatabaseId: "",
+  threshold: 7
+};
+var APP_DIR = join(homedir(), ".ai-blogger");
+var CONFIG_PATH = join(APP_DIR, "config.json");
+function loadConfig(configPath = CONFIG_PATH) {
+  try {
+    const raw = readFileSync(configPath, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { ...DEFAULT_CONFIG, ...parsed };
+  } catch {
+    return { ...DEFAULT_CONFIG };
+  }
+}
+function saveConfig(configPath, config) {
+  mkdirSync(dirname(configPath), { recursive: true });
+  writeFileSync(configPath, JSON.stringify(config, null, 2));
+}
+
+// src/logger.ts
+import { appendFileSync, mkdirSync as mkdirSync2, readFileSync as readFileSync2, statSync, writeFileSync as writeFileSync2 } from "fs";
+import { dirname as dirname2, join as join2 } from "path";
+var MAX_LOG_SIZE = 1024 * 1024;
+var LOG_PATH = join2(APP_DIR, "ai-blogger.log");
+function formatEntry(level, message) {
+  const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+  return `[${timestamp}] [${level}] ${message}
+`;
+}
+function truncateIfNeeded(logPath) {
+  try {
+    const stat = statSync(logPath);
+    if (stat.size > MAX_LOG_SIZE) {
+      const content = readFileSync2(logPath, "utf-8");
+      const half = content.slice(content.length / 2);
+      const firstNewline = half.indexOf("\n");
+      writeFileSync2(logPath, firstNewline >= 0 ? half.slice(firstNewline + 1) : half);
+    }
+  } catch {
+  }
+}
+function writeLog(logPath, level, message) {
+  mkdirSync2(dirname2(logPath), { recursive: true });
+  truncateIfNeeded(logPath);
+  appendFileSync(logPath, formatEntry(level, message));
+}
+function createLogger(logPath = LOG_PATH) {
+  return {
+    info: (message) => writeLog(logPath, "INFO", message),
+    error: (message) => writeLog(logPath, "ERROR", message)
+  };
+}
+
+// src/transcript.ts
+import { readFileSync as readFileSync3 } from "fs";
+var MAX_TOOL_RESULT_LENGTH = 500;
+var MAX_CHAR_BUDGET = 15e4;
+function readTranscript(transcriptPath) {
+  try {
+    const raw = readFileSync3(transcriptPath, "utf-8");
+    const lines = raw.split("\n").filter((l) => l.trim());
+    const entries = [];
+    for (const line of lines) {
+      try {
+        entries.push(JSON.parse(line));
+      } catch {
+      }
+    }
+    return entries;
+  } catch {
+    return [];
+  }
+}
+function entryText(entry) {
+  if (typeof entry.content === "string") return entry.content;
+  if (entry.message) {
+    const c = entry.message.content;
+    if (typeof c === "string") return c;
+    if (Array.isArray(c)) {
+      return c.filter((p) => p.type === "text").map((p) => p.text).join("\n");
+    }
+  }
+  return "";
+}
+function estimateChars(entries) {
+  return entries.reduce((sum, e) => sum + entryText(e).length + 20, 0);
+}
+function preprocessTranscript(entries) {
+  let filtered = entries.filter(
+    (e) => e.type !== "system" && !e.isMeta
+  );
+  filtered = filtered.map((e) => {
+    if (e.type === "tool_result" && typeof e.content === "string" && e.content.length > MAX_TOOL_RESULT_LENGTH) {
+      return { ...e, content: e.content.slice(0, MAX_TOOL_RESULT_LENGTH) + "\n...[truncated]" };
+    }
+    return e;
+  });
+  if (estimateChars(filtered) <= MAX_CHAR_BUDGET) {
+    return filtered;
+  }
+  const headCount = Math.floor(filtered.length * 0.3);
+  const tailCount = Math.floor(filtered.length * 0.3);
+  const head = filtered.slice(0, headCount);
+  const tail = filtered.slice(filtered.length - tailCount);
+  const separator = {
+    type: "system",
+    content: `...[${filtered.length - headCount - tailCount} messages omitted for brevity]...`
+  };
+  return [...head, separator, ...tail];
+}
+function transcriptToText(entries) {
+  return entries.map((e) => {
+    const role = e.type === "user" ? "User" : e.type === "assistant" ? "Assistant" : e.type;
+    const text = entryText(e);
+    return `[${role}]: ${text}`;
+  }).join("\n\n");
+}
+
+// src/analyzer.ts
+import Anthropic from "@anthropic-ai/sdk";
+var SYSTEM_PROMPT = `\uB2F9\uC2E0\uC740 \uAC1C\uBC1C \uBE14\uB85C\uADF8 \uAE00\uAC10 \uBD84\uC11D \uC2DC\uC2A4\uD15C\uC785\uB2C8\uB2E4.
+\uC0AC\uC6A9\uC790\uAC00 \uC81C\uACF5\uD558\uB294 \uD14D\uC2A4\uD2B8\uB294 Claude Code \uC138\uC158\uC758 \uB300\uD654 \uAE30\uB85D\uC785\uB2C8\uB2E4.
+\uC774 \uB300\uD654\uB97C \uBD84\uC11D\uD558\uC5EC \uBE14\uB85C\uADF8 \uAE00\uAC10\uC774 \uB420 \uB9CC\uD55C \uB0B4\uC6A9\uC774 \uC788\uB294\uC9C0 \uD310\uB2E8\uD558\uC138\uC694.
+
+\uC8FC\uC758: \uB300\uD654 \uB0B4\uC6A9\uC5D0 \uC751\uB2F5\uD558\uAC70\uB098 \uC774\uC5B4\uAC00\uC9C0 \uB9C8\uC138\uC694. \uC624\uC9C1 \uBD84\uC11D\uB9CC \uC218\uD589\uD558\uC138\uC694.
+
+\uAE00\uAC10 \uAE30\uC900:
+- \uD765\uBBF8\uB85C\uC6B4 \uBC84\uADF8 \uD574\uACB0 \uACFC\uC815 (\uB514\uBC84\uAE45 \uC2A4\uD1A0\uB9AC)
+- \uC0C8\uB85C\uC6B4 \uAE30\uC220/\uD328\uD134\uC744 \uC801\uC6A9\uD55C \uC0AC\uB840
+- \uC720\uC6A9\uD55C \uAC1C\uBC1C \uC778\uC0AC\uC774\uD2B8/\uD301
+
+\uBC18\uB4DC\uC2DC \uC544\uB798 JSON \uD615\uC2DD\uC73C\uB85C\uB9CC \uC751\uB2F5\uD558\uC138\uC694. \uB2E4\uB978 \uD14D\uC2A4\uD2B8\uB97C \uC808\uB300 \uD3EC\uD568\uD558\uC9C0 \uB9C8\uC138\uC694:
+{"score": 1~10, "category": "debugging"|"tech-pattern"|"insight", "title": "\uC81C\uC548 \uC81C\uBAA9", "reason": "\uD55C \uC904 \uC124\uBA85"}`;
+var ANALYZER_SYSTEM_PROMPT = SYSTEM_PROMPT;
+function buildAnalyzerUserMessage(transcriptText) {
+  return `\uB2E4\uC74C\uC740 Claude Code \uC138\uC158 \uB300\uD654 \uB0B4\uC6A9\uC785\uB2C8\uB2E4:
+
+---
+
+${transcriptText}`;
+}
+function parseAnalyzerResponse(text) {
+  try {
+    const codeBlockMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?```/);
+    const jsonStr = codeBlockMatch ? codeBlockMatch[1].trim() : text.trim();
+    const parsed = JSON.parse(jsonStr);
+    if (typeof parsed.score !== "number" || typeof parsed.category !== "string" || typeof parsed.title !== "string" || typeof parsed.reason !== "string") {
+      return null;
+    }
+    return {
+      score: parsed.score,
+      category: parsed.category,
+      title: parsed.title,
+      reason: parsed.reason
+    };
+  } catch {
+    return null;
+  }
+}
+async function analyze(transcriptText, apiKey, options) {
+  const log = options?.log ?? (() => {
+  });
+  const client = new Anthropic({ apiKey });
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: 300,
+    system: ANALYZER_SYSTEM_PROMPT,
+    messages: [
+      {
+        role: "user",
+        content: buildAnalyzerUserMessage(transcriptText)
+      }
+    ]
+  });
+  const content = response.content[0];
+  if (content.type !== "text") {
+    log(`Unexpected content type: ${content.type}`);
+    return null;
+  }
+  log(`Raw response: ${content.text.slice(0, 500)}`);
+  const result = parseAnalyzerResponse(content.text);
+  if (!result) {
+    log(`Failed to parse response: ${content.text}`);
+  }
+  return result;
+}
+
+// src/writer.ts
+import Anthropic2 from "@anthropic-ai/sdk";
+var SYSTEM_PROMPT2 = `\uB2F9\uC2E0\uC740 \uD55C\uAD6D\uC5B4 \uAC1C\uBC1C \uBE14\uB85C\uADF8 \uAE00 \uC0DD\uC131 \uC2DC\uC2A4\uD15C\uC785\uB2C8\uB2E4.
+\uC0AC\uC6A9\uC790\uAC00 \uC81C\uACF5\uD558\uB294 \uD14D\uC2A4\uD2B8\uB294 Claude Code \uC138\uC158\uC758 \uB300\uD654 \uAE30\uB85D\uC785\uB2C8\uB2E4.
+\uC774 \uB300\uD654\uB97C \uAE30\uBC18\uC73C\uB85C \uBE14\uB85C\uADF8 \uAE00\uC744 \uC791\uC131\uD558\uC138\uC694.
+
+\uC8FC\uC758: \uB300\uD654 \uB0B4\uC6A9\uC5D0 \uC751\uB2F5\uD558\uAC70\uB098 \uC774\uC5B4\uAC00\uC9C0 \uB9C8\uC138\uC694. \uC624\uC9C1 \uBE14\uB85C\uADF8 \uAE00 \uC791\uC131\uB9CC \uC218\uD589\uD558\uC138\uC694.
+
+\uC791\uC131 \uAC00\uC774\uB4DC:
+- \uB3C5\uC790\uB294 \uAC1C\uBC1C\uC790
+- \uBB38\uC81C -> \uACFC\uC815 -> \uD574\uACB0 -> \uBC30\uC6B4 \uC810 \uAD6C\uC870
+- \uD575\uC2EC \uCF54\uB4DC \uC2A4\uB2C8\uD3AB \uD3EC\uD568
+- \uC790\uC5F0\uC2A4\uB7EC\uC6B4 \uD55C\uAD6D\uC5B4, \uAE30\uC220 \uC6A9\uC5B4\uB294 \uC6D0\uBB38 \uC720\uC9C0
+- 1000~2000\uC790 \uBD84\uB7C9
+
+\uBC18\uB4DC\uC2DC \uC544\uB798 JSON \uD615\uC2DD\uC73C\uB85C\uB9CC \uC751\uB2F5\uD558\uC138\uC694. JSON \uC678\uC758 \uD14D\uC2A4\uD2B8\uB97C \uC808\uB300 \uD3EC\uD568\uD558\uC9C0 \uB9C8\uC138\uC694:
+{"title": "\uCD5C\uC885 \uC81C\uBAA9", "tags": ["tag1", "tag2"], "content": "\uB9C8\uD06C\uB2E4\uC6B4 \uBCF8\uBB38"}`;
+var WRITER_SYSTEM_PROMPT = SYSTEM_PROMPT2;
+function buildWriterUserMessage(transcriptText, category, suggestedTitle) {
+  return `\uCE74\uD14C\uACE0\uB9AC: ${category}
+\uC81C\uC548 \uC81C\uBAA9: ${suggestedTitle}
+
+---
+
+${transcriptText}`;
+}
+function parseWriterResponse(text) {
+  try {
+    const parsed = JSON.parse(text.trim());
+    if (typeof parsed.title === "string" && Array.isArray(parsed.tags) && typeof parsed.content === "string") {
+      return { title: parsed.title, tags: parsed.tags, content: parsed.content };
+    }
+  } catch {
+  }
+  try {
+    const firstBrace = text.indexOf("{");
+    if (firstBrace >= 0) {
+      let depth = 0;
+      let start = firstBrace;
+      for (let i = firstBrace; i < text.length; i++) {
+        if (text[i] === "{") depth++;
+        else if (text[i] === "}") {
+          depth--;
+          if (depth === 0) {
+            const candidate = text.slice(start, i + 1);
+            const parsed = JSON.parse(candidate);
+            if (typeof parsed.title === "string" && Array.isArray(parsed.tags) && typeof parsed.content === "string") {
+              return { title: parsed.title, tags: parsed.tags, content: parsed.content };
+            }
+            break;
+          }
+        }
+      }
+    }
+  } catch {
+  }
+  return null;
+}
+async function writeBlogPost(transcriptText, category, suggestedTitle, apiKey, options) {
+  const log = options?.log ?? (() => {
+  });
+  const client = new Anthropic2({ apiKey });
+  const response = await client.messages.create({
+    model: "claude-sonnet-4-6",
+    max_tokens: 4096,
+    system: WRITER_SYSTEM_PROMPT,
+    messages: [{ role: "user", content: buildWriterUserMessage(transcriptText, category, suggestedTitle) }]
+  });
+  const content = response.content[0];
+  if (content.type !== "text") {
+    log(`Unexpected content type: ${content.type}`);
+    return null;
+  }
+  log(`Raw response length: ${content.text.length} chars`);
+  const result = parseWriterResponse(content.text);
+  if (!result) {
+    log(`Failed to parse response. First 500 chars: ${content.text.slice(0, 500)}`);
+  }
+  return result;
+}
+
+// src/notion.ts
+import { Client } from "@notionhq/client";
+import { markdownToBlocks as martianMarkdownToBlocks } from "@tryfabric/martian";
+function buildNotionProperties(titlePropertyName, title, tags, category, score) {
+  return {
+    [titlePropertyName]: {
+      title: [{ text: { content: title } }]
+    },
+    Tags: {
+      multi_select: tags.map((name) => ({ name }))
+    },
+    Category: {
+      select: { name: category }
+    },
+    Score: {
+      number: score
+    }
+  };
+}
+function markdownToBlocks(markdown) {
+  if (!markdown.trim()) return [];
+  return martianMarkdownToBlocks(markdown);
+}
+async function ensureProperties(notion, databaseId) {
+  const db = await notion.databases.retrieve({ database_id: databaseId });
+  let titleProp = "Name";
+  for (const [name, prop] of Object.entries(db.properties)) {
+    if (prop.type === "title") {
+      titleProp = name;
+      break;
+    }
+  }
+  const existing = new Set(Object.keys(db.properties));
+  const updates = {};
+  if (!existing.has("Tags")) {
+    updates["Tags"] = { multi_select: {} };
+  }
+  if (!existing.has("Category")) {
+    updates["Category"] = { select: {} };
+  }
+  if (!existing.has("Score")) {
+    updates["Score"] = { number: {} };
+  }
+  if (Object.keys(updates).length > 0) {
+    await notion.databases.update({
+      database_id: databaseId,
+      properties: updates
+    });
+  }
+  return titleProp;
+}
+async function createNotionPage(post, category, score, notionToken, databaseId) {
+  const notion = new Client({ auth: notionToken });
+  const titleProp = await ensureProperties(notion, databaseId);
+  const properties = buildNotionProperties(titleProp, post.title, post.tags, category, score);
+  const children = markdownToBlocks(post.content);
+  const response = await notion.pages.create({
+    parent: { database_id: databaseId },
+    properties,
+    children
+  });
+  return response.id;
+}
+
+// src/queue.ts
+import {
+  readFileSync as readFileSync4,
+  writeFileSync as writeFileSync3,
+  unlinkSync,
+  mkdirSync as mkdirSync3
+} from "fs";
+import { dirname as dirname3, join as join3 } from "path";
+import { createHash } from "crypto";
+var LOCK_PATH = join3(APP_DIR, "lock");
+var QUEUE_PATH = join3(APP_DIR, "queue.json");
+var HISTORY_PATH = join3(APP_DIR, "history.json");
+var MAX_HISTORY = 100;
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function acquireLock(lockPath = LOCK_PATH) {
+  mkdirSync3(dirname3(lockPath), { recursive: true });
+  try {
+    writeFileSync3(lockPath, String(process.pid), { flag: "wx" });
+    return true;
+  } catch {
+    try {
+      const pid = parseInt(readFileSync4(lockPath, "utf-8").trim(), 10);
+      if (!isNaN(pid) && !isProcessAlive(pid)) {
+        unlinkSync(lockPath);
+        try {
+          writeFileSync3(lockPath, String(process.pid), { flag: "wx" });
+          return true;
+        } catch {
+          return false;
+        }
+      }
+    } catch {
+    }
+    return false;
+  }
+}
+function releaseLock(lockPath = LOCK_PATH) {
+  try {
+    unlinkSync(lockPath);
+  } catch {
+  }
+}
+function readJson(path, fallback) {
+  try {
+    return JSON.parse(readFileSync4(path, "utf-8"));
+  } catch {
+    return fallback;
+  }
+}
+function writeJson(path, data) {
+  mkdirSync3(dirname3(path), { recursive: true });
+  writeFileSync3(path, JSON.stringify(data));
+}
+function enqueue(queuePath = QUEUE_PATH, transcriptPath) {
+  const queue = readJson(queuePath, []);
+  queue.push(transcriptPath);
+  writeJson(queuePath, queue);
+}
+function dequeue(queuePath = QUEUE_PATH) {
+  const queue = readJson(queuePath, []);
+  if (queue.length === 0) return null;
+  const item = queue.shift();
+  writeJson(queuePath, queue);
+  return item;
+}
+function hashContent(content) {
+  return createHash("sha256").update(content).digest("hex").slice(0, 16);
+}
+function addToHistory(historyPath = HISTORY_PATH, hash) {
+  const history = readJson(historyPath, []);
+  history.push(hash);
+  const trimmed = history.slice(-MAX_HISTORY);
+  writeJson(historyPath, trimmed);
+}
+function isInHistory(historyPath = HISTORY_PATH, hash) {
+  const history = readJson(historyPath, []);
+  return history.includes(hash);
+}
+
+// src/pipeline.ts
+async function processTranscript(transcriptPath, config, logger, options) {
+  const { dryRun = false, skipHistory = false } = options ?? {};
+  const entries = readTranscript(transcriptPath);
+  if (entries.length === 0) {
+    logger.info(`Empty transcript: ${transcriptPath}`);
+    return "empty";
+  }
+  const processed = preprocessTranscript(entries);
+  const text = transcriptToText(processed);
+  const hash = hashContent(text);
+  if (!skipHistory && isInHistory(HISTORY_PATH, hash)) {
+    logger.info(`Duplicate transcript skipped: ${hash}`);
+    return "duplicate";
+  }
+  logger.info(`Analyzing transcript: ${transcriptPath} (${entries.length} entries, ${text.length} chars)`);
+  const analysis = await analyze(text, config.anthropicApiKey, { log: (msg) => logger.info(`[analyzer] ${msg}`) });
+  if (!analysis) {
+    logger.error(`Analysis failed for: ${transcriptPath}`);
+    return "analyze-failed";
+  }
+  logger.info(`Analysis result: score=${analysis.score}, category=${analysis.category}, title="${analysis.title}"`);
+  if (analysis.score < config.threshold) {
+    logger.info(`Score ${analysis.score} below threshold ${config.threshold}, skipping`);
+    addToHistory(HISTORY_PATH, hash);
+    return "low-score";
+  }
+  logger.info(`Generating blog post: "${analysis.title}"`);
+  const post = await writeBlogPost(text, analysis.category, analysis.title, config.anthropicApiKey, { log: (msg) => logger.info(`[writer] ${msg}`) });
+  if (!post) {
+    logger.error(`Blog post generation failed for: ${analysis.title}`);
+    return "write-failed";
+  }
+  logger.info(`Blog post generated: "${post.title}" (${post.content.length} chars, tags: ${post.tags.join(", ")})`);
+  if (dryRun) {
+    logger.info(`[dry-run] Skipping Notion upload. Blog post preview:
+${post.content.slice(0, 500)}...`);
+    return "dry-run-done";
+  }
+  logger.info(`Publishing to Notion: "${post.title}"`);
+  try {
+    const pageId = await createNotionPage(
+      post,
+      analysis.category,
+      analysis.score,
+      config.notionToken,
+      config.notionDatabaseId
+    );
+    logger.info(`Published to Notion: pageId=${pageId}`);
+  } catch (err) {
+    logger.error(`Notion publish failed: ${err instanceof Error ? err.message : err}`);
+    return "publish-failed";
+  }
+  addToHistory(HISTORY_PATH, hash);
+  return "published";
+}
+
+// src/install.ts
+import { readFileSync as readFileSync5, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { dirname as dirname4, join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+var SETTINGS_PATH = join4(homedir2(), ".claude", "settings.json");
+var HOOK_COMMAND = "npx ai-blogger process";
+var MANAGED_EVENTS = ["Stop"];
+function loadSettings(path) {
+  try {
+    return JSON.parse(readFileSync5(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveSettings(settings, path) {
+  mkdirSync4(dirname4(path), { recursive: true });
+  writeFileSync4(path, JSON.stringify(settings, null, 2));
+}
+function isAiBloggerHook(entry) {
+  return entry.hooks?.some((h) => h.command?.startsWith(HOOK_COMMAND)) ?? false;
+}
+function makeHookEntry() {
+  return {
+    hooks: [{ type: "command", command: HOOK_COMMAND, timeout: 15 }]
+  };
+}
+function installHooks(settingsPath = SETTINGS_PATH) {
+  const settings = loadSettings(settingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  const added = [];
+  const skipped = [];
+  for (const event of MANAGED_EVENTS) {
+    const existing = settings.hooks[event] || [];
+    if (existing.some(isAiBloggerHook)) {
+      skipped.push(event);
+    } else {
+      settings.hooks[event] = [...existing, makeHookEntry()];
+      added.push(event);
+    }
+  }
+  saveSettings(settings, settingsPath);
+  return { added, skipped };
+}
+function uninstallHooks(settingsPath = SETTINGS_PATH) {
+  const settings = loadSettings(settingsPath);
+  if (!settings.hooks) settings.hooks = {};
+  const removed = [];
+  const notFound = [];
+  for (const event of MANAGED_EVENTS) {
+    const existing = settings.hooks[event] || [];
+    const filtered = existing.filter((e) => !isAiBloggerHook(e));
+    if (filtered.length < existing.length) {
+      removed.push(event);
+      if (filtered.length === 0) {
+        delete settings.hooks[event];
+      } else {
+        settings.hooks[event] = filtered;
+      }
+    } else {
+      notFound.push(event);
+    }
+  }
+  if (Object.keys(settings.hooks).length === 0) {
+    delete settings.hooks;
+  }
+  saveSettings(settings, settingsPath);
+  return { removed, notFound };
+}
+
+// src/cli.ts
+function parseStdin(raw) {
+  try {
+    return JSON.parse(raw) || {};
+  } catch {
+    return {};
+  }
+}
+function readStdin() {
+  return new Promise((resolve) => {
+    let data = "";
+    const timeout = setTimeout(() => resolve(data), 5e3);
+    if (process.stdin.isTTY) {
+      clearTimeout(timeout);
+      resolve("");
+      return;
+    }
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => {
+      clearTimeout(timeout);
+      resolve(data);
+    });
+    process.stdin.on("error", () => {
+      clearTimeout(timeout);
+      resolve("");
+    });
+  });
+}
+async function handleProcess() {
+  const stdinRaw = await readStdin();
+  const data = parseStdin(stdinRaw);
+  const transcriptPath = data.transcript_path;
+  if (!transcriptPath) {
+    console.error("No transcript_path in stdin");
+    return;
+  }
+  const __filename2 = fileURLToPath(import.meta.url);
+  const child = spawn(
+    process.execPath,
+    [__filename2, "__run-pipeline", transcriptPath],
+    {
+      detached: true,
+      stdio: "ignore"
+    }
+  );
+  child.unref();
+}
+async function runPipeline(transcriptPath) {
+  const logger = createLogger();
+  const config = loadConfig();
+  if (!config.anthropicApiKey || !config.notionToken || !config.notionDatabaseId) {
+    logger.error("Missing required config (anthropicApiKey, notionToken, notionDatabaseId)");
+    return;
+  }
+  if (!acquireLock()) {
+    logger.info(`Lock held, enqueueing: ${transcriptPath}`);
+    enqueue(QUEUE_PATH, transcriptPath);
+    return;
+  }
+  try {
+    const result = await processTranscript(transcriptPath, config, logger);
+    logger.info(`Pipeline result for ${transcriptPath}: ${result}`);
+    let next;
+    while ((next = dequeue()) !== null) {
+      logger.info(`Processing queued: ${next}`);
+      const qResult = await processTranscript(next, config, logger);
+      logger.info(`Pipeline result for ${next}: ${qResult}`);
+    }
+  } catch (err) {
+    logger.error(`Pipeline error: ${err instanceof Error ? err.message : err}`);
+  } finally {
+    releaseLock();
+  }
+}
+function handleConfig(args) {
+  if (args.includes("--show")) {
+    console.log(JSON.stringify(loadConfig(), null, 2));
+    return;
+  }
+  const VALID_KEYS = ["anthropicApiKey", "notionToken", "notionDatabaseId", "threshold"];
+  const setIdx = args.indexOf("--set");
+  if (setIdx !== -1 && args[setIdx + 1] && args[setIdx + 2]) {
+    const key = args[setIdx + 1];
+    const value = args[setIdx + 2];
+    if (!VALID_KEYS.includes(key)) {
+      console.error(`Unknown config key: ${key}. Valid keys: ${VALID_KEYS.join(", ")}`);
+      return;
+    }
+    const config = loadConfig();
+    if (key === "threshold") {
+      config.threshold = parseInt(value, 10);
+    } else {
+      config[key] = value;
+    }
+    saveConfig(CONFIG_PATH, config);
+    console.log(`Config updated: ${key} = ${value}`);
+    return;
+  }
+  console.log("Usage: ai-blogger config --show | --set <key> <value>");
+}
+function handleInstall() {
+  const { added, skipped } = installHooks();
+  if (added.length > 0) console.log(`Hooks added: ${added.join(", ")}`);
+  if (skipped.length > 0) console.log(`Already installed: ${skipped.join(", ")}`);
+  console.log("Install complete.");
+}
+function handleUninstall() {
+  const { removed, notFound } = uninstallHooks();
+  if (removed.length > 0) console.log(`Hooks removed: ${removed.join(", ")}`);
+  if (notFound.length > 0) console.log(`Not found: ${notFound.join(", ")}`);
+  console.log("Uninstall complete.");
+}
+function findLatestTranscript() {
+  const claudeDir = join5(homedir3(), ".claude", "projects");
+  try {
+    const projects = readdirSync(claudeDir);
+    let latest = null;
+    for (const project of projects) {
+      const projectDir = join5(claudeDir, project);
+      try {
+        const files = readdirSync(projectDir);
+        for (const file of files) {
+          if (!file.endsWith(".jsonl")) continue;
+          const fullPath = join5(projectDir, file);
+          const stat = statSync2(fullPath);
+          if (!latest || stat.mtimeMs > latest.mtime) {
+            latest = { path: fullPath, mtime: stat.mtimeMs };
+          }
+        }
+      } catch {
+      }
+    }
+    return latest?.path ?? null;
+  } catch {
+    return null;
+  }
+}
+async function handleTest(args) {
+  const config = loadConfig();
+  if (!args.includes("--dry-run") && !args.includes("--full")) {
+    if (!config.anthropicApiKey) {
+      console.error("anthropicApiKey not set. Run: ai-blogger config --set anthropicApiKey <key>");
+      return;
+    }
+    if (!config.notionToken || !config.notionDatabaseId) {
+      console.error("Notion config not set. Run: ai-blogger config --set notionToken/notionDatabaseId <value>");
+      return;
+    }
+    console.log("Config OK. Pipeline is ready.");
+    console.log(`Log file: ${LOG_PATH}`);
+    console.log("\nRun with --dry-run (analyze + generate, no Notion) or --full (including Notion upload)");
+    return;
+  }
+  if (!config.anthropicApiKey) {
+    console.error("anthropicApiKey not set. Run: ai-blogger config --set anthropicApiKey <key>");
+    return;
+  }
+  const dryRun = args.includes("--dry-run");
+  const full = args.includes("--full");
+  if (full && (!config.notionToken || !config.notionDatabaseId)) {
+    console.error("Notion config not set for --full test. Run: ai-blogger config --set notionToken/notionDatabaseId <value>");
+    return;
+  }
+  const fileIdx = args.indexOf("--file");
+  const transcriptPath = fileIdx !== -1 && args[fileIdx + 1] ? args[fileIdx + 1] : findLatestTranscript();
+  if (!transcriptPath) {
+    console.error("No transcript found. Use --file <path> to specify one.");
+    return;
+  }
+  console.log(`Using transcript: ${transcriptPath}`);
+  console.log(dryRun ? "Mode: dry-run (no Notion upload)" : "Mode: full (including Notion upload)");
+  console.log("Running pipeline...\n");
+  const logger = createLogger();
+  const consoleLogger = {
+    info: (msg) => {
+      logger.info(msg);
+      console.log(`  [INFO] ${msg}`);
+    },
+    error: (msg) => {
+      logger.error(msg);
+      console.error(`  [ERROR] ${msg}`);
+    }
+  };
+  const result = await processTranscript(transcriptPath, config, consoleLogger, {
+    dryRun,
+    skipHistory: true
+  });
+  console.log(`
+Result: ${result}`);
+}
+async function main() {
+  const args = process.argv.slice(2);
+  const command = args[0];
+  try {
+    switch (command) {
+      case "process":
+        await handleProcess();
+        break;
+      case "__run-pipeline":
+        await runPipeline(args[1]);
+        break;
+      case "config":
+        handleConfig(args.slice(1));
+        break;
+      case "install":
+        handleInstall();
+        break;
+      case "uninstall":
+        handleUninstall();
+        break;
+      case "test":
+        await handleTest(args.slice(1));
+        break;
+      case "--version":
+      case "-v": {
+        const { createRequire } = await import("module");
+        const require2 = createRequire(import.meta.url);
+        const { version } = require2("../package.json");
+        console.log(version);
+        break;
+      }
+      default:
+        console.log("Usage: ai-blogger <install|uninstall|process|config|test|--version>");
+    }
+  } catch (err) {
+    console.error("Error:", err instanceof Error ? err.message : err);
+  }
+}
+main();
+export {
+  parseStdin
+};

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ai-blogger",
+  "version": "0.1.0",
+  "description": "Auto-generate blog posts from Claude Code sessions to Notion",
+  "type": "module",
+  "bin": {
+    "ai-blogger": "./dist/cli.js"
+  },
+  "files": ["dist"],
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": ["claude-code", "blog", "notion", "ai"],
+  "license": "MIT",
+  "engines": {
+    "node": ">=18"
+  },
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.52.0",
+    "@notionhq/client": "^2.3.0",
+    "@tryfabric/martian": "^1.2.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.5.1",
+    "typescript": "^5.7.0",
+    "vitest": "^3.1.0"
+  }
+}