@tiey/synth 0.0.1

package/dist/index.js

@@ -0,0 +1,1831 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+
+// src/config/loader.ts
+import fs from "fs";
+import path from "path";
+import os from "os";
+import { parse as parseYaml } from "yaml";
+
+// src/config/schema.ts
+import { z } from "zod";
+var llmConfigSchema = z.object({
+  provider: z.enum(["openai-compatible", "anthropic", "ollama"]).default("openai-compatible"),
+  baseUrl: z.string().default("https://api.openai.com/v1"),
+  apiKey: z.string().default(""),
+  model: z.string().default("gpt-4o"),
+  contextWindow: z.number().int().positive().default(128e3),
+  maxTokens: z.number().int().positive().default(4096),
+  maxConcurrency: z.number().int().positive().default(5),
+  headers: z.record(z.string(), z.string()).default({})
+});
+var agentConfigSchema = z.object({
+  role: z.string().default(""),
+  systemPrompt: z.string().default(""),
+  mapPrompt: z.string().default(""),
+  reducePrompt: z.string().default(""),
+  reportPrompt: z.string().default("")
+});
+var scheduleConfigSchema = z.object({
+  cron: z.string().default("0 1-23 * * *")
+});
+var collectorConfigSchema = z.object({
+  adapters: z.array(z.string()).default(["claude-code", "codex", "qoder"])
+});
+var outputConfigSchema = z.object({
+  formats: z.array(z.enum(["markdown", "html"])).default(["markdown", "html"]),
+  dir: z.string().default("~/.synth/reports")
+});
+var defaultLlmConfig = llmConfigSchema.parse({});
+var defaultAgentConfig = agentConfigSchema.parse({});
+var defaultScheduleConfig = scheduleConfigSchema.parse({});
+var defaultCollectorConfig = collectorConfigSchema.parse({});
+var defaultOutputConfig = outputConfigSchema.parse({});
+var configSchema = z.object({
+  llm: llmConfigSchema.default(defaultLlmConfig),
+  agent: agentConfigSchema.default(defaultAgentConfig),
+  schedule: scheduleConfigSchema.default(defaultScheduleConfig),
+  collector: collectorConfigSchema.default(defaultCollectorConfig),
+  output: outputConfigSchema.default(defaultOutputConfig)
+});
+var defaultConfigYaml = `# Synth config
+
+llm:
+  provider: "openai-compatible"
+  baseUrl: "https://api.openai.com/v1"
+  apiKey: ""
+  model: "gpt-4o"
+  contextWindow: 128000
+  maxTokens: 4096
+  maxConcurrency: 5
+  headers: {}
+
+agent:
+  role: ""
+  systemPrompt: ""
+  mapPrompt: ""
+  reducePrompt: ""
+  reportPrompt: ""
+
+schedule:
+  cron: "0 1-23 * * *"
+
+collector:
+  adapters:
+    - claude-code
+    - codex
+    - qoder
+
+output:
+  formats:
+    - markdown
+    - html
+  dir: "~/.synth/reports"
+`;
+
+// src/config/loader.ts
+function getSynthDir() {
+  return path.join(os.homedir(), ".synth");
+}
+function getConfigPath() {
+  return path.join(getSynthDir(), "config.yaml");
+}
+function initConfig() {
+  const configPath = getConfigPath();
+  const dir = path.dirname(configPath);
+  if (!fs.existsSync(dir)) {
+    fs.mkdirSync(dir, { recursive: true });
+  }
+  if (fs.existsSync(configPath)) {
+    return `\u914D\u7F6E\u6587\u4EF6\u5DF2\u5B58\u5728: ${configPath}`;
+  }
+  fs.writeFileSync(configPath, defaultConfigYaml, "utf-8");
+  return `\u914D\u7F6E\u6587\u4EF6\u5DF2\u751F\u6210: ${configPath}`;
+}
+function loadConfig() {
+  const configPath = getConfigPath();
+  let raw = {};
+  if (fs.existsSync(configPath)) {
+    const content = fs.readFileSync(configPath, "utf-8");
+    raw = parseYaml(content) ?? {};
+  }
+  return configSchema.parse(raw);
+}
+
+// src/runner.ts
+import { createHash } from "crypto";
+import fs9 from "fs";
+import os7 from "os";
+import path9 from "path";
+
+// src/agent/prompts.ts
+var defaultPrompts = {
+  role: "AI\u7F16\u7A0B\u5DE5\u4F5C\u8BB0\u5F55\u5206\u6790\u5E08",
+  systemPrompt: `\u4F60\u662F\u4E00\u4F4D\u4E13\u4E1A\u7684\u5DE5\u4F5C\u5185\u5BB9\u5206\u6790\u5E08\u3002\u4F60\u7684\u4EFB\u52A1\u662F\u5206\u6790\u7528\u6237\u4E0EAI\u7F16\u7A0B\u52A9\u624B\u7684\u5BF9\u8BDD\u8BB0\u5F55\uFF0C
+\u63D0\u53D6\u5173\u952E\u5DE5\u4F5C\u5185\u5BB9\uFF0C\u751F\u6210\u7B80\u6D01\u51C6\u786E\u7684\u5DE5\u4F5C\u6458\u8981\u3002
+\u8981\u6C42\uFF1A
+- \u5173\u6CE8\u5B9E\u9645\u5B8C\u6210\u7684\u5DE5\u4F5C\uFF0C\u800C\u975E\u5BF9\u8BDD\u8FC7\u7A0B
+- \u63D0\u53D6\u4FEE\u6539\u7684\u6587\u4EF6\u3001\u89E3\u51B3\u7684\u95EE\u9898\u3001\u5B9E\u73B0\u7684\u529F\u80FD
+- \u4F7F\u7528\u7B80\u6D01\u7684\u4E2D\u6587\u63CF\u8FF0
+- \u5FFD\u7565\u95F2\u804A\u3001\u7CFB\u7EDF\u63D0\u793A\u7B49\u65E0\u5173\u5185\u5BB9`,
+  mapPrompt: `\u4EE5\u4E0B\u662F {{tool}} \u4E2D\u7684\u4E00\u6BB5\u5BF9\u8BDD\u8BB0\u5F55\uFF08\u7B2C {{chunkIndex}}/{{totalChunks}} \u7247\uFF09\u3002
+\u5DE5\u4F5C\u76EE\u5F55\uFF1A{{workingDir}}
+\u65F6\u95F4\u8303\u56F4\uFF1A{{startTime}} ~ {{endTime}}
+\u8BF7\u63D0\u53D6\u672C\u7247\u6BB5\u4E2D\u7684\u5173\u952E\u5DE5\u4F5C\u5185\u5BB9\uFF0C\u4EE5\u8981\u70B9\u5217\u8868\u5F62\u5F0F\u8F93\u51FA\u3002
+---
+{{content}}`,
+  reducePrompt: `\u4EE5\u4E0B\u662F\u540C\u4E00\u4F1A\u8BDD\u62C6\u5206\u540E\u7684\u5404\u7247\u6BB5\u6458\u8981\uFF0C\u8BF7\u5408\u5E76\u4E3A\u4E00\u4EFD\u5B8C\u6574\u6458\u8981\uFF0C\u53BB\u91CD\u5E76\u6309\u65F6\u95F4\u7EBF\u7EC4\u7EC7\uFF1A
+{{summaries}}`,
+  reportPrompt: `\u8BF7\u5C06\u4EE5\u4E0B\u4F1A\u8BDD\u6458\u8981\u6574\u5408\u4E3A\u5DE5\u4F5C\u65E5\u62A5\uFF0C\u4E25\u683C\u6309\u7167\u6307\u5B9A\u683C\u5F0F\u8F93\u51FA\u3002
+\u65E5\u671F\uFF1A{{date}}
+\u8981\u6C42\u683C\u5F0F\uFF1A
+# {{date}} \u5DE5\u4F5C\u65E5\u62A5
+## <\u5DE5\u4F5C\u76EE\u5F55>
+### <\u65F6\u95F4\u6BB5>
+- <\u5DE5\u4F5C\u5185\u5BB9>
+\u5408\u5E76\u89C4\u5219\uFF1A
+- \u540C\u4E00\u5DE5\u4F5C\u76EE\u5F55\u4E0B\u7684\u591A\u4E2A\u4F1A\u8BDD\uFF0C\u6309\u65F6\u95F4\u6BB5\u5206\u522B\u5217\u51FA
+- \u65F6\u95F4\u6BB5\u683C\u5F0F\u4E3A HH:MM~HH:MM
+---
+{{sessionSummaries}}`
+};
+function renderTemplate(template, vars) {
+  return template.replace(/\{\{(\w+)\}\}/g, (_, key) => vars[key] ?? "");
+}
+
+// src/processor/preprocessor.ts
+var BASE64_PATTERN = /data:[a-zA-Z0-9+/]+;base64,[A-Za-z0-9+/=]{100,}/g;
+var SYSTEM_REMINDER_PATTERN = /<system-reminder>[\s\S]*?<\/system-reminder>/g;
+var DEFERRED_TOOLS_PATTERN = /<functions>[\s\S]*?<\/functions>/g;
+var TOOL_RESULT_MAX_LEN = 200;
+function preprocessMessages(messages) {
+  const result = [];
+  for (const msg of messages) {
+    const cleaned = cleanContent(msg.content);
+    if (!cleaned.trim()) continue;
+    result.push({
+      role: msg.role,
+      content: cleaned,
+      timestamp: msg.timestamp
+    });
+  }
+  return result;
+}
+function cleanContent(content) {
+  let text = content;
+  text = text.replace(/\[thinking\][^\n]*/g, "");
+  text = text.replace(BASE64_PATTERN, "[base64 content removed]");
+  text = text.replace(SYSTEM_REMINDER_PATTERN, "");
+  text = text.replace(DEFERRED_TOOLS_PATTERN, "");
+  text = text.replace(/<attachment>[\s\S]*?<\/attachment>/g, "");
+  text = text.replace(/\[tool_result\]\s*([\s\S]*?)(?=\n\[|$)/g, (match, resultContent) => {
+    const trimmed = resultContent.trim();
+    if (trimmed.length > TOOL_RESULT_MAX_LEN) {
+      return `[tool_result] ${trimmed.slice(0, TOOL_RESULT_MAX_LEN)}...`;
+    }
+    return `[tool_result] ${trimmed}`;
+  });
+  text = text.replace(/\[tool_use:\s*(\w+)\]\s*([\s\S]*?)(?=\n\[|$)/g, (match, name, input) => {
+    const trimmedInput = input.trim();
+    if (trimmedInput.length > 500) {
+      return `[tool_use: ${name}] ${trimmedInput.slice(0, 500)}...`;
+    }
+    return `[tool_use: ${name}] ${trimmedInput}`;
+  });
+  text = text.replace(/\n{3,}/g, "\n\n");
+  return text.trim();
+}
+
+// src/processor/chunker.ts
+var DEFAULT_OPTIONS = {
+  maxTokensPerChunk: 5e4,
+  overlapMessages: 3
+};
+function estimateTokens(text) {
+  return Math.ceil(text.length / 3);
+}
+function estimateMessagesTokens(messages) {
+  return messages.reduce((sum, m) => sum + estimateTokens(m.content), 0);
+}
+function chunkMessages(messages, options) {
+  const opts = { ...DEFAULT_OPTIONS, ...options };
+  const totalTokens = estimateMessagesTokens(messages);
+  if (totalTokens <= opts.maxTokensPerChunk) {
+    return [{
+      messages,
+      chunkIndex: 1,
+      totalChunks: 1,
+      startTime: messages[0].timestamp,
+      endTime: messages[messages.length - 1].timestamp
+    }];
+  }
+  const pairBoundaries = [0];
+  for (let i = 1; i < messages.length; i++) {
+    if (messages[i].role === "user") {
+      pairBoundaries.push(i);
+    }
+  }
+  const rawChunks = [];
+  let currentChunk = [];
+  let currentTokens = 0;
+  for (let p = 0; p < pairBoundaries.length; p++) {
+    const pairStart = pairBoundaries[p];
+    const pairEnd = p + 1 < pairBoundaries.length ? pairBoundaries[p + 1] : messages.length;
+    const pairMessages = messages.slice(pairStart, pairEnd);
+    const pairTokens = pairMessages.reduce((sum, m) => sum + estimateTokens(m.content), 0);
+    if (currentChunk.length > 0 && currentTokens + pairTokens > opts.maxTokensPerChunk) {
+      rawChunks.push(currentChunk);
+      currentChunk = [];
+      currentTokens = 0;
+    }
+    currentChunk.push(...pairMessages);
+    currentTokens += pairTokens;
+  }
+  if (currentChunk.length > 0) {
+    rawChunks.push(currentChunk);
+  }
+  const totalChunks = rawChunks.length;
+  const chunks = rawChunks.map((chunkMsgs, i) => {
+    let finalMessages = chunkMsgs;
+    if (i > 0 && opts.overlapMessages > 0) {
+      const prevChunk = rawChunks[i - 1];
+      const overlapStart = Math.max(0, prevChunk.length - opts.overlapMessages);
+      const overlap = prevChunk.slice(overlapStart);
+      finalMessages = [...overlap, ...chunkMsgs];
+    }
+    return {
+      messages: finalMessages,
+      chunkIndex: i + 1,
+      totalChunks,
+      startTime: finalMessages[0].timestamp,
+      endTime: finalMessages[finalMessages.length - 1].timestamp
+    };
+  });
+  return chunks;
+}
+
+// src/agent/semaphore.ts
+var Semaphore = class {
+  constructor(max) {
+    this.max = max;
+  }
+  max;
+  queue = [];
+  running = 0;
+  async acquire() {
+    if (this.running < this.max) {
+      this.running++;
+      return;
+    }
+    return new Promise((resolve) => this.queue.push(resolve));
+  }
+  release() {
+    this.running--;
+    const next = this.queue.shift();
+    if (next) {
+      this.running++;
+      next();
+    }
+  }
+};
+
+// src/logger.ts
+import fs2 from "fs";
+import path2 from "path";
+import pino from "pino";
+function ensureLogDir() {
+  const logDir = path2.join(getSynthDir(), "logs");
+  if (!fs2.existsSync(logDir)) {
+    fs2.mkdirSync(logDir, { recursive: true });
+  }
+  return logDir;
+}
+function createLogger(level = "info") {
+  const logDir = ensureLogDir();
+  const logFile = path2.join(logDir, "synth.log");
+  return pino(
+    { level },
+    pino.transport({
+      targets: [
+        {
+          target: "pino/file",
+          options: { destination: logFile, mkdir: true },
+          level
+        },
+        {
+          target: "pino-pretty",
+          options: { colorize: true },
+          level
+        }
+      ]
+    })
+  );
+}
+var _logger;
+function getLogger() {
+  if (!_logger) {
+    _logger = createLogger();
+  }
+  return _logger;
+}
+
+// src/agent/summarizer.ts
+var MAX_RETRIES = 2;
+function formatTime(date) {
+  return date.toLocaleTimeString("zh-CN", { hour: "2-digit", minute: "2-digit", hour12: false });
+}
+function getPrompt(config, key) {
+  const custom = config.agent[key];
+  return custom && custom.trim() ? custom : defaultPrompts[key];
+}
+function messagesToText(messages) {
+  return messages.map((m) => `[${m.role}] ${m.content}`).join("\n\n");
+}
+var Summarizer = class {
+  provider;
+  config;
+  semaphore;
+  constructor(provider, config) {
+    this.provider = provider;
+    this.config = config;
+    this.semaphore = new Semaphore(config.llm.maxConcurrency);
+  }
+  /**
+   * Summarize a single session: preprocess → chunk if needed → summarize.
+   */
+  async summarizeSession(session) {
+    const logger = getLogger();
+    const preprocessed = preprocessMessages(session.messages);
+    const totalTokens = estimateMessagesTokens(preprocessed);
+    const systemPrompt = getPrompt(this.config, "systemPrompt");
+    const threshold = this.config.llm.contextWindow - this.config.llm.maxTokens - 2e3;
+    logger.debug({
+      sessionId: session.sessionId.slice(0, 8),
+      totalTokens,
+      threshold,
+      messageCount: preprocessed.length
+    }, "Session \u6458\u8981\u5F00\u59CB");
+    let summary;
+    if (totalTokens <= threshold) {
+      summary = await this.singlePassSummarize(session, preprocessed, systemPrompt);
+    } else {
+      summary = await this.mapReduceSummarize(session, preprocessed, systemPrompt, threshold);
+    }
+    logger.info({
+      sessionId: session.sessionId.slice(0, 8),
+      tool: session.tool,
+      workingDir: session.workingDir
+    }, "Session \u6458\u8981\u5B8C\u6210");
+    return {
+      sessionId: session.sessionId,
+      tool: session.tool,
+      workingDir: session.workingDir,
+      startTime: session.startTime,
+      endTime: session.endTime,
+      summary
+    };
+  }
+  async singlePassSummarize(session, messages, systemPrompt) {
+    const content = messagesToText(messages);
+    const mapPrompt = renderTemplate(getPrompt(this.config, "mapPrompt"), {
+      tool: session.tool,
+      workingDir: session.workingDir,
+      startTime: formatTime(session.startTime),
+      endTime: formatTime(session.endTime),
+      chunkIndex: "1",
+      totalChunks: "1",
+      content
+    });
+    return this.callWithRetry([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: mapPrompt }
+    ]);
+  }
+  async mapReduceSummarize(session, messages, systemPrompt, maxTokensPerChunk) {
+    const logger = getLogger();
+    const chunks = chunkMessages(messages, { maxTokensPerChunk });
+    logger.info({
+      sessionId: session.sessionId.slice(0, 8),
+      chunks: chunks.length
+    }, "MapReduce \u5206\u7247");
+    const mapResults = await Promise.all(
+      chunks.map(async (chunk) => {
+        await this.semaphore.acquire();
+        try {
+          const content = messagesToText(chunk.messages);
+          const mapPrompt = renderTemplate(getPrompt(this.config, "mapPrompt"), {
+            tool: session.tool,
+            workingDir: session.workingDir,
+            startTime: formatTime(chunk.startTime),
+            endTime: formatTime(chunk.endTime),
+            chunkIndex: String(chunk.chunkIndex),
+            totalChunks: String(chunk.totalChunks),
+            content
+          });
+          const result = await this.callWithRetry([
+            { role: "system", content: systemPrompt },
+            { role: "user", content: mapPrompt }
+          ]);
+          logger.debug({
+            sessionId: session.sessionId.slice(0, 8),
+            chunk: `${chunk.chunkIndex}/${chunk.totalChunks}`
+          }, "Map \u7247\u6BB5\u5B8C\u6210");
+          return result;
+        } catch (err) {
+          logger.error({
+            sessionId: session.sessionId.slice(0, 8),
+            chunk: `${chunk.chunkIndex}/${chunk.totalChunks}`,
+            err
+          }, "Map \u7247\u6BB5\u5931\u8D25\uFF0C\u8DF3\u8FC7");
+          return null;
+        } finally {
+          this.semaphore.release();
+        }
+      })
+    );
+    const validSummaries = mapResults.filter((s) => s !== null);
+    if (validSummaries.length === 0) {
+      return "\uFF08\u6458\u8981\u751F\u6210\u5931\u8D25\uFF09";
+    }
+    if (validSummaries.length === 1) {
+      return validSummaries[0];
+    }
+    const summariesText = validSummaries.map((s, i) => `--- \u7247\u6BB5 ${i + 1} ---
+${s}`).join("\n\n");
+    const reducePrompt = renderTemplate(getPrompt(this.config, "reducePrompt"), {
+      summaries: summariesText
+    });
+    return this.callWithRetry([
+      { role: "system", content: systemPrompt },
+      { role: "user", content: reducePrompt }
+    ]);
+  }
+  async callWithRetry(messages) {
+    const logger = getLogger();
+    let lastError;
+    for (let attempt = 0; attempt <= MAX_RETRIES; attempt++) {
+      try {
+        return await this.provider.chat(messages);
+      } catch (err) {
+        lastError = err;
+        if (attempt < MAX_RETRIES) {
+          const delay = 1e3 * (attempt + 1);
+          logger.warn({ attempt: attempt + 1, err }, `LLM \u8C03\u7528\u5931\u8D25\uFF0C${delay}ms \u540E\u91CD\u8BD5`);
+          await new Promise((r) => setTimeout(r, delay));
+        }
+      }
+    }
+    throw lastError;
+  }
+};
+
+// src/agent/providers/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  model;
+  maxTokens;
+  constructor(config) {
+    this.client = new Anthropic({
+      baseURL: config.baseUrl,
+      apiKey: config.apiKey
+    });
+    this.model = config.model;
+    this.maxTokens = config.maxTokens;
+  }
+  async chat(messages, options) {
+    let system;
+    const conversationMessages = [];
+    for (const msg of messages) {
+      if (msg.role === "system") {
+        system = msg.content;
+      } else {
+        conversationMessages.push({
+          role: msg.role,
+          content: msg.content
+        });
+      }
+    }
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: options?.maxTokens ?? this.maxTokens,
+      system,
+      messages: conversationMessages
+    });
+    const textBlock = response.content.find((b) => b.type === "text");
+    return textBlock?.type === "text" ? textBlock.text : "";
+  }
+};
+
+// src/agent/providers/openai-compatible.ts
+import OpenAI from "openai";
+var OpenAICompatibleProvider = class {
+  client;
+  model;
+  maxTokens;
+  constructor(config) {
+    this.client = new OpenAI({
+      baseURL: config.baseUrl,
+      apiKey: config.apiKey,
+      defaultHeaders: config.headers
+    });
+    this.model = config.model;
+    this.maxTokens = config.maxTokens;
+  }
+  async chat(messages, options) {
+    const response = await this.client.chat.completions.create({
+      model: this.model,
+      messages: messages.map((m) => ({
+        role: m.role,
+        content: m.content
+      })),
+      max_tokens: options?.maxTokens ?? this.maxTokens,
+      temperature: options?.temperature ?? 0.3
+    });
+    return response.choices[0]?.message?.content ?? "";
+  }
+};
+
+// src/collector/claude-code.adapter.ts
+import fs3 from "fs";
+import os2 from "os";
+import path3 from "path";
+import readline from "readline";
+function decodeProjectDir(encoded) {
+  const match = encoded.match(/^([A-Za-z])--(.*)?$/);
+  if (!match) return encoded;
+  const drive = match[1].toUpperCase();
+  const rest = match[2] ? match[2].replace(/-/g, "\\") : "";
+  return rest ? `${drive}:\\${rest}` : `${drive}:\\`;
+}
+function getClaudeDir() {
+  return path3.join(os2.homedir(), ".claude");
+}
+function isMessageInWindow(timestamp, since, until) {
+  return timestamp > since && timestamp <= until;
+}
+var ClaudeCodeAdapter = class {
+  name = "claude-code";
+  async detect() {
+    return fs3.existsSync(path3.join(getClaudeDir(), "projects"));
+  }
+  async collectSessions(since, until) {
+    const logger = getLogger();
+    const projectsDir = path3.join(getClaudeDir(), "projects");
+    const results = [];
+    const projectDirs = fs3.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const projectDir of projectDirs) {
+      const workingDir = decodeProjectDir(projectDir.name);
+      const projectPath = path3.join(projectsDir, projectDir.name);
+      const jsonlFiles = fs3.readdirSync(projectPath).filter((f) => f.endsWith(".jsonl"));
+      for (const file of jsonlFiles) {
+        const filePath = path3.join(projectPath, file);
+        const sessionId = path3.basename(file, ".jsonl");
+        const stat = fs3.statSync(filePath);
+        if (stat.mtime <= since) continue;
+        try {
+          const session = await this.parseSession(filePath, sessionId, workingDir, since, until);
+          if (session) {
+            results.push(session);
+          }
+        } catch (err) {
+          logger.warn({ file: filePath, err }, "Claude Code session parse failed");
+        }
+      }
+    }
+    return results;
+  }
+  async parseSession(filePath, sessionId, workingDir, since, until) {
+    const messages = [];
+    let cwd = workingDir;
+    const stream = fs3.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.cwd) {
+        cwd = entry.cwd;
+      }
+      if (entry.type !== "user" && entry.type !== "assistant") continue;
+      if (!entry.message) continue;
+      const timestamp = entry.timestamp ? new Date(entry.timestamp) : null;
+      if (!timestamp || !isMessageInWindow(timestamp, since, until)) continue;
+      const role = entry.message.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const content = extractTextContent(entry.message.content);
+      if (!content) continue;
+      messages.push({ role, content, timestamp });
+    }
+    if (messages.length === 0) return null;
+    return {
+      tool: "claude-code",
+      sessionId,
+      workingDir: cwd,
+      startTime: messages[0].timestamp,
+      endTime: messages[messages.length - 1].timestamp,
+      messages
+    };
+  }
+};
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") {
+        parts.push(b.text);
+      } else if (b.type === "tool_use") {
+        const input = b.input ? JSON.stringify(b.input) : "";
+        parts.push(`[tool_use: ${b.name}] ${input}`);
+      } else if (b.type === "tool_result") {
+        const text = typeof b.content === "string" ? b.content : "";
+        parts.push(`[tool_result] ${text}`);
+      } else if (b.type === "thinking") {
+        parts.push(`[thinking] ${b.thinking || ""}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+
+// src/collector/codex.adapter.ts
+import fs4 from "fs";
+import os3 from "os";
+import path4 from "path";
+import readline2 from "readline";
+function getCodexDir() {
+  return path4.join(os3.homedir(), ".codex");
+}
+function isMessageInWindow2(timestamp, since, until) {
+  return timestamp > since && timestamp <= until;
+}
+var CodexAdapter = class {
+  name = "codex";
+  async detect() {
+    return fs4.existsSync(path4.join(getCodexDir(), "sessions"));
+  }
+  async collectSessions(since, until) {
+    const logger = getLogger();
+    const sessionsDir = path4.join(getCodexDir(), "sessions");
+    const results = [];
+    const sessionFiles = this.findSessionFiles(sessionsDir, since, until);
+    for (const filePath of sessionFiles) {
+      const sessionId = path4.basename(filePath, ".jsonl");
+      try {
+        const session = await this.parseSession(filePath, sessionId, since, until);
+        if (session) {
+          results.push(session);
+        }
+      } catch (err) {
+        logger.warn({ file: filePath, err }, "Codex session parse failed");
+      }
+    }
+    return results;
+  }
+  findSessionFiles(sessionsDir, since, until) {
+    const files = [];
+    if (!fs4.existsSync(sessionsDir)) return files;
+    const years = fs4.readdirSync(sessionsDir, { withFileTypes: true }).filter((d) => d.isDirectory() && /^\d{4}$/.test(d.name));
+    for (const yearDir of years) {
+      const yearPath = path4.join(sessionsDir, yearDir.name);
+      const months = fs4.readdirSync(yearPath, { withFileTypes: true }).filter((d) => d.isDirectory() && /^\d{2}$/.test(d.name));
+      for (const monthDir of months) {
+        const monthPath = path4.join(yearPath, monthDir.name);
+        const days = fs4.readdirSync(monthPath, { withFileTypes: true }).filter((d) => d.isDirectory() && /^\d{2}$/.test(d.name));
+        for (const dayDir of days) {
+          const dirDate = /* @__PURE__ */ new Date(`${yearDir.name}-${monthDir.name}-${dayDir.name}T00:00:00`);
+          const dirDateEnd = new Date(dirDate);
+          dirDateEnd.setDate(dirDateEnd.getDate() + 1);
+          if (dirDateEnd <= since || dirDate > until) continue;
+          const dayPath = path4.join(monthPath, dayDir.name);
+          const jsonlFiles = fs4.readdirSync(dayPath).filter((f) => f.endsWith(".jsonl")).map((f) => path4.join(dayPath, f));
+          files.push(...jsonlFiles);
+        }
+      }
+    }
+    return files;
+  }
+  async parseSession(filePath, sessionId, since, until) {
+    const messages = [];
+    let cwd = "";
+    const stream = fs4.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = readline2.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      const type = entry.type;
+      const timestamp = entry.timestamp ? new Date(entry.timestamp) : null;
+      if (type === "session_meta") {
+        cwd = entry.payload?.cwd || "";
+        continue;
+      }
+      if (type === "turn_context" && entry.payload?.cwd) {
+        cwd = entry.payload.cwd;
+        continue;
+      }
+      if (!timestamp || !isMessageInWindow2(timestamp, since, until)) continue;
+      if (type === "event_msg" && entry.payload?.type === "user_message") {
+        const text = entry.payload.message;
+        if (typeof text === "string" && text.trim()) {
+          messages.push({ role: "user", content: text, timestamp });
+        }
+        continue;
+      }
+      if (type === "response_item") {
+        const payload = entry.payload;
+        if (!payload) continue;
+        const role = payload.role;
+        const content = extractCodexContent(payload.content);
+        if (!content) continue;
+        if (role === "developer" || role === "user") {
+          messages.push({ role: "user", content, timestamp });
+        } else if (role === "assistant") {
+          messages.push({ role: "assistant", content, timestamp });
+        }
+      }
+    }
+    if (messages.length === 0) return null;
+    return {
+      tool: "codex",
+      sessionId,
+      workingDir: cwd,
+      startTime: messages[0].timestamp,
+      endTime: messages[messages.length - 1].timestamp,
+      messages
+    };
+  }
+};
+function extractCodexContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type === "input_text" && typeof b.text === "string") {
+        parts.push(b.text);
+      } else if (b.type === "output_text" && typeof b.text === "string") {
+        parts.push(b.text);
+      } else if (b.type === "function_call") {
+        parts.push(`[tool_use: ${b.name}] ${b.arguments || ""}`);
+      } else if (b.type === "function_call_output") {
+        const output = typeof b.output === "string" ? b.output : "";
+        parts.push(`[tool_result] ${output}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+
+// src/collector/qoder.adapter.ts
+import fs5 from "fs";
+import os4 from "os";
+import path5 from "path";
+import readline3 from "readline";
+function getQoderDir() {
+  return path5.join(os4.homedir(), ".qoder");
+}
+function isMessageInWindow3(timestamp, since, until) {
+  return timestamp > since && timestamp <= until;
+}
+var QoderAdapter = class {
+  name = "qoder";
+  async detect() {
+    return fs5.existsSync(path5.join(getQoderDir(), "projects"));
+  }
+  async collectSessions(since, until) {
+    const logger = getLogger();
+    const projectsDir = path5.join(getQoderDir(), "projects");
+    const results = [];
+    const projectDirs = fs5.readdirSync(projectsDir, { withFileTypes: true }).filter((d) => d.isDirectory());
+    for (const projectDir of projectDirs) {
+      const projectPath = path5.join(projectsDir, projectDir.name);
+      const sessionFiles = fs5.readdirSync(projectPath).filter((f) => f.endsWith("-session.json"));
+      for (const sessionFile of sessionFiles) {
+        const metaPath = path5.join(projectPath, sessionFile);
+        try {
+          const raw = fs5.readFileSync(metaPath, "utf-8");
+          const meta = JSON.parse(raw);
+          const createdAt = new Date(meta.created_at);
+          const updatedAt = new Date(meta.updated_at);
+          if (createdAt > until || updatedAt <= since) continue;
+          const jsonlFile = path5.join(projectPath, `${meta.id}.jsonl`);
+          if (!fs5.existsSync(jsonlFile)) continue;
+          const session = await this.parseSession(jsonlFile, meta, since, until);
+          if (session) {
+            results.push(session);
+          }
+        } catch (err) {
+          logger.warn({ file: metaPath, err }, "Qoder session parse failed");
+        }
+      }
+    }
+    return results;
+  }
+  async parseSession(filePath, meta, since, until) {
+    const messages = [];
+    const stream = fs5.createReadStream(filePath, { encoding: "utf-8" });
+    const rl = readline3.createInterface({ input: stream, crlfDelay: Infinity });
+    for await (const line of rl) {
+      if (!line.trim()) continue;
+      let entry;
+      try {
+        entry = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      if (entry.type !== "user" && entry.type !== "assistant") continue;
+      if (!entry.message) continue;
+      const timestamp = entry.timestamp ? new Date(entry.timestamp) : null;
+      if (!timestamp || !isMessageInWindow3(timestamp, since, until)) continue;
+      const role = entry.message.role;
+      if (role !== "user" && role !== "assistant") continue;
+      const content = extractQoderContent(entry.message.content);
+      if (!content) continue;
+      messages.push({ role, content, timestamp });
+    }
+    if (messages.length === 0) return null;
+    return {
+      tool: "qoder",
+      sessionId: meta.id,
+      workingDir: meta.working_dir,
+      startTime: messages[0].timestamp,
+      endTime: messages[messages.length - 1].timestamp,
+      messages
+    };
+  }
+};
+function extractQoderContent(content) {
+  if (typeof content === "string") return content;
+  if (Array.isArray(content)) {
+    const parts = [];
+    for (const block of content) {
+      if (!block || typeof block !== "object") continue;
+      const b = block;
+      if (b.type === "text" && typeof b.text === "string") {
+        parts.push(b.text);
+      } else if (b.type === "tool_use") {
+        const input = b.input ? JSON.stringify(b.input) : "";
+        parts.push(`[tool_use: ${b.name}] ${input}`);
+      } else if (b.type === "tool_result") {
+        const text = typeof b.content === "string" ? b.content : "";
+        parts.push(`[tool_result] ${text}`);
+      } else if (b.type === "thinking") {
+        parts.push(`[thinking] ${b.thinking || ""}`);
+      }
+    }
+    return parts.join("\n");
+  }
+  return "";
+}
+
+// src/collector/registry.ts
+var AdapterRegistry = class {
+  adapters = /* @__PURE__ */ new Map();
+  register(adapter) {
+    this.adapters.set(adapter.name, adapter);
+  }
+  async collectAll(since, until, enabledAdapters) {
+    const logger = getLogger();
+    const results = [];
+    for (const [name, adapter] of this.adapters) {
+      if (enabledAdapters && !enabledAdapters.includes(name)) {
+        continue;
+      }
+      const detected = await adapter.detect();
+      if (!detected) {
+        logger.debug({ adapter: name }, "\u672A\u68C0\u6D4B\u5230\u6570\u636E\u76EE\u5F55\uFF0C\u8DF3\u8FC7");
+        continue;
+      }
+      try {
+        const sessions = await adapter.collectSessions(since, until);
+        logger.info({ adapter: name, count: sessions.length }, "\u91C7\u96C6\u5B8C\u6210");
+        results.push(...sessions);
+      } catch (err) {
+        logger.error({ adapter: name, err }, "\u91C7\u96C6\u5931\u8D25");
+      }
+    }
+    return results;
+  }
+};
+
+// src/report/html.ts
+import fs6 from "fs";
+import os5 from "os";
+import path6 from "path";
+import { marked } from "marked";
+var CSS = `
+body {
+  font-family: -apple-system, BlinkMacSystemFont, "Segoe UI", Roboto, "Helvetica Neue", Arial, sans-serif;
+  max-width: 900px;
+  margin: 0 auto;
+  padding: 40px 20px;
+  color: #333;
+  line-height: 1.6;
+  background: #fafafa;
+}
+h1 {
+  color: #1a1a1a;
+  border-bottom: 2px solid #e1e4e8;
+  padding-bottom: 12px;
+  font-size: 1.8em;
+}
+h2 {
+  color: #24292e;
+  margin-top: 32px;
+  padding: 8px 12px;
+  background: #f0f4f8;
+  border-left: 4px solid #0366d6;
+  border-radius: 4px;
+  font-size: 1.2em;
+  font-family: "Cascadia Code", "Fira Code", Consolas, monospace;
+}
+h3 {
+  color: #586069;
+  font-size: 1em;
+  margin-top: 20px;
+  font-weight: 600;
+}
+h4 {
+  color: #333;
+  font-size: 0.95em;
+  margin-top: 16px;
+}
+ul {
+  padding-left: 24px;
+}
+li {
+  margin: 6px 0;
+}
+code {
+  background: #f1f3f5;
+  padding: 2px 6px;
+  border-radius: 3px;
+  font-size: 0.9em;
+}
+hr {
+  border: none;
+  border-top: 1px solid #e1e4e8;
+  margin: 24px 0;
+}
+`.trim();
+function resolveOutputDir(config) {
+  const dir = config.output.dir.replace(/^~/, os5.homedir());
+  return path6.join(dir, "html");
+}
+function generateHtmlReport(date, markdownContent, config) {
+  const logger = getLogger();
+  const htmlBody = marked(markdownContent);
+  const html = `<!DOCTYPE html>
+<html lang="zh-CN">
+<head>
+  <meta charset="UTF-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1.0">
+  <title>${date} \u5DE5\u4F5C\u65E5\u62A5</title>
+  <style>${CSS}</style>
+</head>
+<body>
+${htmlBody}
+</body>
+</html>`;
+  const outputDir = resolveOutputDir(config);
+  if (!fs6.existsSync(outputDir)) {
+    fs6.mkdirSync(outputDir, { recursive: true });
+  }
+  const filePath = path6.join(outputDir, `${date}.html`);
+  fs6.writeFileSync(filePath, html, "utf-8");
+  logger.info({ path: filePath }, "HTML report generated");
+  return {
+    content: html,
+    filePath
+  };
+}
+
+// src/report/markdown.ts
+import fs7 from "fs";
+import os6 from "os";
+import path7 from "path";
+function resolveOutputDir2(config) {
+  const dir = config.output.dir.replace(/^~/, os6.homedir());
+  return path7.join(dir, "markdown");
+}
+function formatTime2(date) {
+  return date.toLocaleTimeString("zh-CN", {
+    hour: "2-digit",
+    minute: "2-digit",
+    hour12: false
+  });
+}
+function createReportHeader(date) {
+  return `# ${date} \u5DE5\u4F5C\u65E5\u62A5
+`;
+}
+function renderBatchFragment(summaries) {
+  const sorted = [...summaries].sort((a, b) => a.startTime.getTime() - b.startTime.getTime());
+  const batchStart = sorted[0].startTime;
+  const batchEnd = sorted[sorted.length - 1].endTime;
+  const groups = /* @__PURE__ */ new Map();
+  for (const summary of sorted) {
+    const list = groups.get(summary.workingDir) || [];
+    list.push(summary);
+    groups.set(summary.workingDir, list);
+  }
+  const sections = [
+    `## ${formatTime2(batchStart)}~${formatTime2(batchEnd)}`,
+    ...Array.from(groups.entries()).flatMap(([workingDir, items]) => {
+      const rendered = [`### ${workingDir}`];
+      for (const item of items) {
+        rendered.push(`#### [${item.tool}] ${formatTime2(item.startTime)}~${formatTime2(item.endTime)}`);
+        rendered.push(item.summary.trim());
+      }
+      return rendered;
+    })
+  ];
+  return `${sections.join("\n\n")}
+`;
+}
+async function generateMarkdownReport(date, summaries, _provider, config, options) {
+  const logger = getLogger();
+  const outputDir = resolveOutputDir2(config);
+  if (!fs7.existsSync(outputDir)) {
+    fs7.mkdirSync(outputDir, { recursive: true });
+  }
+  const filePath = path7.join(outputDir, `${date}.md`);
+  const fragment = renderBatchFragment(summaries);
+  if (!options.append || !fs7.existsSync(filePath)) {
+    const content2 = `${createReportHeader(date)}
+${fragment}`.trimEnd() + "\n";
+    fs7.writeFileSync(filePath, content2, "utf-8");
+  } else {
+    const prefix = fs7.statSync(filePath).size > 0 ? "\n" : "";
+    fs7.appendFileSync(filePath, `${prefix}${fragment}`, "utf-8");
+  }
+  const content = fs7.readFileSync(filePath, "utf-8");
+  logger.info({ path: filePath, append: options.append }, "Markdown report updated");
+  return {
+    content,
+    filePath
+  };
+}
+
+// src/store/state.ts
+import fs8 from "fs";
+import path8 from "path";
+import Database from "better-sqlite3";
+var _db;
+function getDb() {
+  if (_db) return _db;
+  const dbDir = getSynthDir();
+  if (!fs8.existsSync(dbDir)) {
+    fs8.mkdirSync(dbDir, { recursive: true });
+  }
+  const dbPath = path8.join(dbDir, "state.sqlite");
+  _db = new Database(dbPath);
+  _db.exec(`
+    CREATE TABLE IF NOT EXISTS kv (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+
+    CREATE TABLE IF NOT EXISTS message_fingerprints (
+      date        TEXT NOT NULL,
+      fingerprint TEXT NOT NULL,
+      created_at  TEXT NOT NULL,
+      PRIMARY KEY (date, fingerprint)
+    );
+  `);
+  return _db;
+}
+function getValue(key) {
+  const db = getDb();
+  const row = db.prepare("SELECT value FROM kv WHERE key = ?").get(key);
+  return row?.value ?? null;
+}
+function setValue(key, value) {
+  const db = getDb();
+  db.prepare(
+    "INSERT INTO kv (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value"
+  ).run(key, value);
+}
+function getDailyCursorKey(date) {
+  return `dailyCursor:${date}`;
+}
+function getDailyCursor(date) {
+  const value = getValue(getDailyCursorKey(date));
+  return value ? new Date(value) : null;
+}
+function setDailyCursor(date, cursor) {
+  setValue(getDailyCursorKey(date), cursor.toISOString());
+}
+function hasMessageFingerprint(date, fingerprint) {
+  const db = getDb();
+  const row = db.prepare("SELECT 1 FROM message_fingerprints WHERE date = ? AND fingerprint = ?").get(date, fingerprint);
+  return !!row;
+}
+function saveMessageFingerprints(date, fingerprints) {
+  if (fingerprints.length === 0) return;
+  const db = getDb();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const stmt = db.prepare(
+    "INSERT OR IGNORE INTO message_fingerprints (date, fingerprint, created_at) VALUES (?, ?, ?)"
+  );
+  const tx = db.transaction((items) => {
+    for (const fingerprint of items) {
+      stmt.run(date, fingerprint, now);
+    }
+  });
+  tx(fingerprints);
+}
+function pruneMessageFingerprints(beforeDate) {
+  const db = getDb();
+  db.prepare("DELETE FROM message_fingerprints WHERE date < ?").run(beforeDate);
+}
+function clearCollectionState() {
+  const db = getDb();
+  db.exec(`
+    DELETE FROM kv WHERE key = 'lastRunAt' OR key LIKE 'dailyCursor:%';
+    DELETE FROM message_fingerprints;
+  `);
+}
+function closeDb() {
+  if (_db) {
+    _db.close();
+    _db = void 0;
+  }
+}
+
+// src/runner.ts
+var SAFETY_LAG_MS = 90 * 1e3;
+var LOOKBACK_MS = 2 * 60 * 1e3;
+function createProvider(config) {
+  if (config.llm.provider === "anthropic") {
+    return new AnthropicProvider({
+      baseUrl: config.llm.baseUrl,
+      apiKey: config.llm.apiKey,
+      model: config.llm.model,
+      maxTokens: config.llm.maxTokens
+    });
+  }
+  return new OpenAICompatibleProvider({
+    baseUrl: config.llm.baseUrl,
+    apiKey: config.llm.apiKey,
+    model: config.llm.model,
+    maxTokens: config.llm.maxTokens,
+    headers: config.llm.headers
+  });
+}
+function createRegistry(config) {
+  const registry = new AdapterRegistry();
+  const adapters = {
+    "claude-code": () => new ClaudeCodeAdapter(),
+    codex: () => new CodexAdapter(),
+    qoder: () => new QoderAdapter()
+  };
+  for (const name of config.collector.adapters) {
+    const factory = adapters[name];
+    if (factory) {
+      registry.register(factory());
+    }
+  }
+  return registry;
+}
+function formatDate(date) {
+  const y = date.getFullYear();
+  const m = String(date.getMonth() + 1).padStart(2, "0");
+  const d = String(date.getDate()).padStart(2, "0");
+  return `${y}-${m}-${d}`;
+}
+function startOfDay(date) {
+  const value = new Date(date);
+  value.setHours(0, 0, 0, 0);
+  return value;
+}
+function endOfDay(date) {
+  const value = new Date(date);
+  value.setHours(23, 59, 59, 999);
+  return value;
+}
+function maxDate(left, right) {
+  return left > right ? left : right;
+}
+function getSafeUntil(now) {
+  return new Date(now.getTime() - SAFETY_LAG_MS);
+}
+function fingerprintMessage(session, message) {
+  const digest = createHash("sha1").update(session.tool).update("\n").update(session.sessionId).update("\n").update(message.timestamp.toISOString()).update("\n").update(message.role).update("\n").update(message.content).digest("hex");
+  return `${session.tool}:${session.sessionId}:${digest}`;
+}
+function filterDuplicateMessages(date, sessions) {
+  const filtered = [];
+  for (const session of sessions) {
+    const messages = session.messages.filter((message) => !hasMessageFingerprint(date, fingerprintMessage(session, message)));
+    if (messages.length === 0) continue;
+    filtered.push({
+      ...session,
+      startTime: messages[0].timestamp,
+      endTime: messages[messages.length - 1].timestamp,
+      messages
+    });
+  }
+  return filtered;
+}
+function collectSessionFingerprints(session) {
+  return session.messages.map((message) => fingerprintMessage(session, message));
+}
+function summarizeSessionsConfig(config, sessions, provider) {
+  const logger = getLogger();
+  const summarizer = new Summarizer(provider, config);
+  return (async () => {
+    const summaries = [];
+    const fingerprints = [];
+    let hadFailures = false;
+    for (const session of sessions) {
+      try {
+        const summary = await summarizer.summarizeSession(session);
+        summaries.push(summary);
+        fingerprints.push(...collectSessionFingerprints(session));
+        logger.info(
+          {
+            tool: session.tool,
+            workingDir: session.workingDir,
+            sessionId: session.sessionId.slice(0, 8),
+            startTime: session.startTime.toISOString(),
+            endTime: session.endTime.toISOString(),
+            messages: session.messages.length
+          },
+          "Session summarized"
+        );
+      } catch (err) {
+        hadFailures = true;
+        logger.error(
+          {
+            sessionId: session.sessionId.slice(0, 8),
+            err
+          },
+          "Session summarize failed and was skipped"
+        );
+      }
+    }
+    return { summaries, fingerprints, hadFailures };
+  })();
+}
+function resolveOutputBaseDir(config) {
+  return config.output.dir.replace(/^~/, os7.homedir());
+}
+function clearHistoricalReports(config) {
+  const logger = getLogger();
+  const baseDir = resolveOutputBaseDir(config);
+  const targets = [
+    { dir: path9.join(baseDir, "markdown"), ext: ".md" },
+    { dir: path9.join(baseDir, "html"), ext: ".html" }
+  ];
+  for (const target of targets) {
+    if (!fs9.existsSync(target.dir)) continue;
+    for (const file of fs9.readdirSync(target.dir)) {
+      if (!file.endsWith(target.ext)) continue;
+      fs9.unlinkSync(path9.join(target.dir, file));
+    }
+    logger.info({ dir: target.dir }, "Historical report directory cleared");
+  }
+}
+function partitionSessionsByDate(sessions) {
+  const groups = /* @__PURE__ */ new Map();
+  for (const session of sessions) {
+    const dateBuckets = /* @__PURE__ */ new Map();
+    for (const message of session.messages) {
+      const dateKey = formatDate(message.timestamp);
+      const list = dateBuckets.get(dateKey) || [];
+      list.push(message);
+      dateBuckets.set(dateKey, list);
+    }
+    for (const [dateKey, messages] of dateBuckets.entries()) {
+      const sessionsForDate = groups.get(dateKey) || [];
+      sessionsForDate.push({
+        ...session,
+        sessionId: `${session.sessionId}:${dateKey}`,
+        startTime: messages[0].timestamp,
+        endTime: messages[messages.length - 1].timestamp,
+        messages
+      });
+      groups.set(dateKey, sessionsForDate);
+    }
+  }
+  return groups;
+}
+async function renderReportsForDate(config, date, summaries, provider, append) {
+  const formats = config.output.formats;
+  if (!formats.includes("markdown") && !formats.includes("html")) {
+    return;
+  }
+  const markdownReport = await generateMarkdownReport(date, summaries, provider, config, {
+    append
+  });
+  if (formats.includes("html")) {
+    generateHtmlReport(date, markdownReport.content, config);
+  }
+}
+async function run(config, options = {}) {
+  const logger = getLogger();
+  if (!config.llm.apiKey) {
+    logger.error("Missing LLM apiKey. Run `synth config --init` and update ~/.synth/config.yaml");
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  let since;
+  let until;
+  let rawSince;
+  let dateStr;
+  let appendReport = true;
+  let updateCursor = true;
+  let enableFingerprintDedup = false;
+  if (options.date) {
+    const targetDay = /* @__PURE__ */ new Date(`${options.date}T00:00:00`);
+    since = startOfDay(targetDay);
+    until = endOfDay(targetDay);
+    rawSince = since;
+    dateStr = options.date;
+    appendReport = false;
+    updateCursor = false;
+  } else if (options.since) {
+    rawSince = options.since;
+    since = options.since;
+    until = getSafeUntil(now);
+    dateStr = formatDate(until);
+    appendReport = true;
+    updateCursor = false;
+  } else {
+    dateStr = formatDate(now);
+    const dayStart = startOfDay(now);
+    const cursor = getDailyCursor(dateStr);
+    rawSince = cursor && cursor > dayStart ? cursor : dayStart;
+    since = maxDate(dayStart, new Date(rawSince.getTime() - LOOKBACK_MS));
+    until = getSafeUntil(now);
+    enableFingerprintDedup = true;
+  }
+  if (formatDate(until) !== dateStr) {
+    until = dateStr === formatDate(now) ? maxDate(startOfDay(now), until) : until;
+  }
+  logger.info(
+    {
+      rawSince: rawSince.toISOString(),
+      since: since.toISOString(),
+      until: until.toISOString(),
+      date: dateStr,
+      appendReport,
+      updateCursor,
+      enableFingerprintDedup,
+      safetyLagMs: options.date ? 0 : SAFETY_LAG_MS,
+      lookbackMs: enableFingerprintDedup ? LOOKBACK_MS : 0
+    },
+    "Run started"
+  );
+  if (until <= since) {
+    logger.info({ since: since.toISOString(), until: until.toISOString(), date: dateStr }, "No new collection window");
+    return;
+  }
+  if (enableFingerprintDedup) {
+    const keepFrom = new Date(startOfDay(now));
+    keepFrom.setDate(keepFrom.getDate() - 2);
+    pruneMessageFingerprints(formatDate(keepFrom));
+  }
+  const registry = createRegistry(config);
+  const collectedSessions = await registry.collectAll(since, until, config.collector.adapters);
+  const sessions = enableFingerprintDedup ? filterDuplicateMessages(dateStr, collectedSessions) : collectedSessions;
+  if (sessions.length === 0) {
+    logger.info("No new messages collected in the requested window");
+    if (updateCursor) {
+      setDailyCursor(dateStr, until);
+    }
+    return;
+  }
+  logger.info({ count: sessions.length }, "Collection finished");
+  const provider = createProvider(config);
+  const { summaries, fingerprints, hadFailures } = await summarizeSessionsConfig(config, sessions, provider);
+  if (summaries.length === 0) {
+    logger.warn("All sessions failed during summarization");
+    return;
+  }
+  await renderReportsForDate(config, dateStr, summaries, provider, appendReport);
+  if (enableFingerprintDedup && fingerprints.length > 0) {
+    saveMessageFingerprints(dateStr, fingerprints);
+    logger.info({ date: dateStr, fingerprints: fingerprints.length }, "Message fingerprints saved");
+  }
+  if (updateCursor && !hadFailures) {
+    setDailyCursor(dateStr, until);
+    logger.info({ date: dateStr, cursor: until.toISOString() }, "Daily cursor updated");
+  } else if (updateCursor && hadFailures) {
+    logger.warn({ date: dateStr }, "Cursor not advanced because some sessions failed; next run will retry with dedup");
+  }
+  logger.info({ date: dateStr, sessions: summaries.length }, "Run finished");
+}
+async function backfillHistory(config) {
+  const logger = getLogger();
+  if (!config.llm.apiKey) {
+    logger.error("Missing LLM apiKey. Run `synth config --init` and update ~/.synth/config.yaml");
+    return;
+  }
+  const now = /* @__PURE__ */ new Date();
+  const safeUntil = getSafeUntil(now);
+  const today = formatDate(safeUntil);
+  logger.info({ until: safeUntil.toISOString() }, "History backfill started");
+  clearCollectionState();
+  clearHistoricalReports(config);
+  const registry = createRegistry(config);
+  const provider = createProvider(config);
+  const sessions = await registry.collectAll(/* @__PURE__ */ new Date(0), safeUntil, config.collector.adapters);
+  if (sessions.length === 0) {
+    logger.info("No sessions found for historical backfill");
+    setDailyCursor(today, safeUntil);
+    return;
+  }
+  const sessionsByDate = partitionSessionsByDate(sessions);
+  const sortedDates = Array.from(sessionsByDate.keys()).sort();
+  const todayFingerprints = [];
+  for (const date of sortedDates) {
+    const dateSessions = sessionsByDate.get(date) || [];
+    const { summaries, fingerprints } = await summarizeSessionsConfig(config, dateSessions, provider);
+    if (summaries.length === 0) {
+      logger.warn({ date }, "No summaries generated for historical date");
+      continue;
+    }
+    await renderReportsForDate(config, date, summaries, provider, false);
+    if (date === today) {
+      todayFingerprints.push(...fingerprints);
+    }
+  }
+  if (todayFingerprints.length > 0) {
+    saveMessageFingerprints(today, todayFingerprints);
+  }
+  setDailyCursor(today, safeUntil);
+  logger.info({ dates: sortedDates.length, until: safeUntil.toISOString() }, "History backfill finished");
+}
+
+// src/service.ts
+import fs10 from "fs";
+import path10 from "path";
+import { execFile } from "child_process";
+import { promisify } from "util";
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+
+// src/scheduler.ts
+import cron from "node-cron";
+function formatNextRun(task) {
+  const nextRun = task.getNextRun();
+  return nextRun ? nextRun.toISOString() : null;
+}
+function startScheduler(config) {
+  const logger = getLogger();
+  const expression = config.schedule.cron;
+  if (!cron.validate(expression)) {
+    throw new Error(`Invalid cron expression: ${expression}`);
+  }
+  const task = cron.schedule(
+    expression,
+    async () => {
+      const startedAt = /* @__PURE__ */ new Date();
+      logger.info(
+        { cron: expression, startedAt: startedAt.toISOString() },
+        "Scheduled run started"
+      );
+      try {
+        await run(config);
+        logger.info(
+          { cron: expression, finishedAt: (/* @__PURE__ */ new Date()).toISOString(), nextRun: formatNextRun(task) },
+          "Scheduled run finished"
+        );
+      } catch (err) {
+        logger.error(
+          {
+            cron: expression,
+            err,
+            finishedAt: (/* @__PURE__ */ new Date()).toISOString(),
+            nextRun: formatNextRun(task)
+          },
+          "Scheduled run failed"
+        );
+      }
+    },
+    {
+      name: "synth-scheduler",
+      noOverlap: true
+    }
+  );
+  task.on("execution:overlap", () => {
+    logger.warn({ cron: expression }, "Scheduled run skipped because previous execution is still running");
+  });
+  task.on("execution:missed", (context) => {
+    logger.warn(
+      { cron: expression, scheduledAt: context.date.toISOString(), triggeredAt: context.triggeredAt.toISOString() },
+      "Scheduled run was missed"
+    );
+  });
+  task.on("execution:failed", (context) => {
+    logger.error(
+      {
+        cron: expression,
+        scheduledAt: context.date.toISOString(),
+        triggeredAt: context.triggeredAt.toISOString(),
+        err: context.execution?.error
+      },
+      "Scheduled execution callback failed"
+    );
+  });
+  logger.info({ cron: expression, nextRun: formatNextRun(task) }, "Scheduler started");
+  return task;
+}
+
+// src/service.ts
+var execFileAsync = promisify(execFile);
+var require2 = createRequire(import.meta.url);
+var nodeWindows = require2("node-windows");
+var SERVICE_NAME = "Synth AI Work Summary Service";
+var SERVICE_DESCRIPTION = "Collect AI coding sessions and generate scheduled work summaries.";
+var SERVICE_ID = SERVICE_NAME.replace(/[^\w]/g, "").toLowerCase();
+function ensureWindows() {
+  if (process.platform !== "win32") {
+    throw new Error("Windows service management is only supported on win32");
+  }
+}
+function ensureDir(dir) {
+  if (!fs10.existsSync(dir)) {
+    fs10.mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getServiceScriptPath() {
+  const currentFile = fileURLToPath(new URL("./index.js", import.meta.url));
+  if (fs10.existsSync(currentFile)) {
+    return currentFile;
+  }
+  const distFallback = path10.resolve(process.cwd(), "dist", "index.js");
+  if (fs10.existsSync(distFallback)) {
+    return distFallback;
+  }
+  throw new Error("Cannot locate dist/index.js. Run `npm run build` before installing the service.");
+}
+function getServiceWorkingDirectory(scriptPath) {
+  const dir = path10.dirname(scriptPath);
+  return path10.basename(dir).toLowerCase() === "dist" ? path10.resolve(dir, "..") : dir;
+}
+function getServiceLogDir() {
+  return ensureDir(path10.join(getSynthDir(), "logs", "service"));
+}
+function createService() {
+  const script = getServiceScriptPath();
+  return new nodeWindows.Service({
+    name: SERVICE_NAME,
+    description: SERVICE_DESCRIPTION,
+    script,
+    scriptOptions: "service-run",
+    workingDirectory: getServiceWorkingDirectory(script),
+    logpath: getServiceLogDir(),
+    maxRestarts: 5,
+    wait: 2,
+    grow: 0.25,
+    stopparentfirst: true,
+    env: {
+      name: "SYNTH_SERVICE",
+      value: "1"
+    }
+  });
+}
+function waitForEvent(service, action, successEvents, failureEvents, mapResult) {
+  return new Promise((resolve, reject) => {
+    const handlers = {};
+    const cleanup = () => {
+      for (const eventName of [...successEvents, ...failureEvents]) {
+        const handler = handlers[eventName];
+        if (handler) {
+          service.removeListener(eventName, handler);
+        }
+      }
+    };
+    for (const eventName of successEvents) {
+      handlers[eventName] = () => {
+        cleanup();
+        resolve(mapResult(eventName));
+      };
+      service.on(eventName, handlers[eventName]);
+    }
+    for (const eventName of failureEvents) {
+      handlers[eventName] = (...args) => {
+        cleanup();
+        const error = args[0] instanceof Error ? args[0] : new Error(String(args[0] ?? eventName));
+        reject(error);
+      };
+      service.on(eventName, handlers[eventName]);
+    }
+    try {
+      action();
+    } catch (err) {
+      cleanup();
+      reject(err);
+    }
+  });
+}
+function normalizeState(rawState) {
+  switch (rawState) {
+    case "RUNNING":
+      return "running";
+    case "STOPPED":
+      return "stopped";
+    case "START_PENDING":
+      return "start-pending";
+    case "STOP_PENDING":
+      return "stop-pending";
+    case "PAUSED":
+      return "paused";
+    default:
+      return rawState ? "unknown" : "not-installed";
+  }
+}
+async function getServiceStatus() {
+  ensureWindows();
+  try {
+    const { stdout, stderr } = await execFileAsync("sc.exe", ["query", SERVICE_ID], {
+      windowsHide: true
+    });
+    const output = `${stdout}
+${stderr}`;
+    const match = output.match(/STATE\s*:\s*\d+\s+([A-Z_]+)/);
+    const rawState = match?.[1];
+    return {
+      installed: true,
+      state: normalizeState(rawState),
+      rawState
+    };
+  } catch (err) {
+    const code = typeof err === "object" && err !== null && "code" in err ? err.code : void 0;
+    const stdout = typeof err === "object" && err !== null && "stdout" in err ? String(err.stdout ?? "") : "";
+    const stderr = typeof err === "object" && err !== null && "stderr" in err ? String(err.stderr ?? "") : "";
+    const message = err instanceof Error ? err.message : String(err);
+    if (code === 1060 || stdout.includes("1060") || stderr.includes("1060") || message.includes("does not exist")) {
+      return { installed: false, state: "not-installed" };
+    }
+    throw err;
+  }
+}
+async function installService() {
+  ensureWindows();
+  const status = await getServiceStatus();
+  if (status.installed) {
+    if (status.state !== "running" && status.state !== "start-pending") {
+      await startService();
+      return getServiceStatus();
+    }
+    return status;
+  }
+  const service = createService();
+  const result = await waitForEvent(
+    service,
+    () => service.install(),
+    ["install", "alreadyinstalled"],
+    ["error", "invalidinstallation"],
+    (eventName) => eventName
+  );
+  if (result === "install") {
+    await startService();
+  }
+  return getServiceStatus();
+}
+async function uninstallService() {
+  ensureWindows();
+  const status = await getServiceStatus();
+  if (!status.installed) {
+    return status;
+  }
+  const service = createService();
+  await waitForEvent(
+    service,
+    () => service.uninstall(),
+    ["uninstall", "alreadyuninstalled"],
+    ["error"],
+    () => void 0
+  );
+  return getServiceStatus();
+}
+async function startService() {
+  ensureWindows();
+  const status = await getServiceStatus();
+  if (!status.installed || status.state === "running" || status.state === "start-pending") {
+    return status;
+  }
+  const service = createService();
+  await waitForEvent(service, () => service.start(), ["start"], ["error"], () => void 0);
+  return getServiceStatus();
+}
+async function stopService() {
+  ensureWindows();
+  const status = await getServiceStatus();
+  if (!status.installed || status.state === "stopped" || status.state === "stop-pending") {
+    return status;
+  }
+  const service = createService();
+  await waitForEvent(service, () => service.stop(), ["stop", "alreadystopped"], ["error"], () => void 0);
+  return getServiceStatus();
+}
+async function runServiceProcess() {
+  const logger = getLogger();
+  const config = loadConfig();
+  const task = startScheduler(config);
+  logger.info({ cron: config.schedule.cron }, "Windows service process started");
+  let shuttingDown = false;
+  const shutdown = async (reason) => {
+    if (shuttingDown) return;
+    shuttingDown = true;
+    logger.info({ reason }, "Windows service process stopping");
+    try {
+      await Promise.resolve(task.stop());
+    } finally {
+      closeDb();
+    }
+    logger.info("Windows service process stopped");
+    process.exit(0);
+  };
+  process.on("SIGINT", () => {
+    void shutdown("SIGINT");
+  });
+  process.on("SIGTERM", () => {
+    void shutdown("SIGTERM");
+  });
+  process.on("message", (message) => {
+    if (message === "shutdown") {
+      void shutdown("shutdown");
+    }
+  });
+}
+
+// src/index.ts
+function formatServiceState(state) {
+  return state.replace(/-/g, " ");
+}
+var program = new Command();
+program.name("synth").description("AI Coding work summary service").version("0.1.0");
+program.command("run").description("Collect sessions and generate a report immediately").option("--since <date>", "Specify the start time").option("--date <date>", "Generate the report for the given date").action(async (options) => {
+  const config = loadConfig();
+  await run(config, {
+    since: options.since ? new Date(options.since) : void 0,
+    date: options.date
+  });
+});
+program.command("config").description("Manage configuration").option("--init", "Create the default config file").action((options) => {
+  if (options.init) {
+    console.log(initConfig());
+    return;
+  }
+  console.log(JSON.stringify(loadConfig(), null, 2));
+});
+program.command("backfill-history").description("Clear collection state and rebuild historical reports from all sessions").action(async () => {
+  const config = loadConfig();
+  await backfillHistory(config);
+});
+program.command("install").description("Install and start the Windows service").action(async () => {
+  const status = await installService();
+  console.log(`service: ${status.installed ? "installed" : "not installed"}`);
+  console.log(`state: ${formatServiceState(status.state)}`);
+});
+program.command("uninstall").description("Stop and remove the Windows service").action(async () => {
+  const status = await uninstallService();
+  console.log(`service: ${status.installed ? "installed" : "not installed"}`);
+  console.log(`state: ${formatServiceState(status.state)}`);
+});
+program.command("start").description("Start the Windows service").action(async () => {
+  const status = await startService();
+  console.log(`service: ${status.installed ? "installed" : "not installed"}`);
+  console.log(`state: ${formatServiceState(status.state)}`);
+});
+program.command("stop").description("Stop the Windows service").action(async () => {
+  const status = await stopService();
+  console.log(`service: ${status.installed ? "installed" : "not installed"}`);
+  console.log(`state: ${formatServiceState(status.state)}`);
+});
+program.command("status").description("Show the Windows service status").action(async () => {
+  const status = await getServiceStatus();
+  console.log(`service: ${status.installed ? "installed" : "not installed"}`);
+  console.log(`state: ${formatServiceState(status.state)}`);
+  if (status.rawState) {
+    console.log(`rawState: ${status.rawState}`);
+  }
+});
+program.command("service-run").description("Internal service host command").action(async () => {
+  await runServiceProcess();
+});
+await program.parseAsync();
+//# sourceMappingURL=index.js.map