@codehourra/llm-iwiki 0.1.0 → 0.1.1

package/src/collectors/gemini.ts

@@ -1,141 +0,0 @@
-import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs'
-import { basename, dirname, join } from 'node:path'
-
-import type { Collector, RawMessage, RawSession } from './types'
-import { deriveTitle, isEphemeralPath } from './util'
-
-const INTERNAL_ROOTS = ['.gemini-internal', '.gemini']
-
-function loadProjectNameMap(geminiRoot: string): Map<string, string> {
-  const nameToPath = new Map<string, string>()
-  const projectsFile = join(geminiRoot, 'projects.json')
-  if (!existsSync(projectsFile)) return nameToPath
-  try {
-    const parsed = JSON.parse(readFileSync(projectsFile, 'utf8')) as { projects?: Record<string, string> }
-    for (const [path, name] of Object.entries(parsed.projects ?? {})) {
-      if (typeof name === 'string' && !nameToPath.has(name)) nameToPath.set(name, path)
-    }
-  } catch {
-    // ignore malformed projects.json
-  }
-  return nameToPath
-}
-
-function looksLikeAbsolutePath(value: string): boolean {
-  const trimmed = value.trim()
-  return trimmed.startsWith('/') && !trimmed.includes('\n') && trimmed.length < 256
-}
-
-function parseChatFile(filePath: string, projectDir: string, nameToPath: Map<string, string>): RawSession | null {
-  let parsed: {
-    sessionId?: string
-    startTime?: string
-    lastUpdated?: string
-    messages?: Array<{ type?: string; content?: unknown; timestamp?: string }>
-  }
-  try {
-    parsed = JSON.parse(readFileSync(filePath, 'utf8'))
-  } catch {
-    return null
-  }
-
-  const messages: RawMessage[] = []
-  for (const message of parsed.messages ?? []) {
-    if (message.type !== 'user' && message.type !== 'gemini') continue
-    const content = typeof message.content === 'string' ? message.content : ''
-    if (content.trim() === '') continue
-    messages.push({
-      role: message.type === 'user' ? 'user' : 'assistant',
-      content,
-      timestamp: typeof message.timestamp === 'string' ? message.timestamp : null,
-    })
-  }
-
-  if (messages.length === 0) return null
-
-  let rawProjectPath = nameToPath.get(projectDir) ?? null
-  if (!rawProjectPath) {
-    const firstUser = messages.find((message) => message.role === 'user')
-    if (firstUser && looksLikeAbsolutePath(firstUser.content)) {
-      rawProjectPath = firstUser.content.trim().replace(/\/+$/, '')
-    }
-  }
-  if (isEphemeralPath(rawProjectPath)) return null
-
-  const timestamps = messages.map((message) => message.timestamp).filter((value): value is string => value != null)
-
-  return {
-    sourceSessionId: parsed.sessionId ?? basename(filePath).replace(/\.json$/, ''),
-    rawPath: filePath,
-    rawProjectPath,
-    title: deriveTitle(messages),
-    createdAt: parsed.startTime ?? timestamps[0] ?? null,
-    updatedAt: parsed.lastUpdated ?? timestamps[timestamps.length - 1] ?? null,
-    messages,
-  }
-}
-
-function resolveGeminiRoot(homeDir: string): string | null {
-  const seen = new Set<string>()
-  for (const root of INTERNAL_ROOTS) {
-    const dir = join(homeDir, root)
-    if (!existsSync(dir)) continue
-    let canonical: string
-    try {
-      canonical = realpathSync(dir)
-    } catch {
-      canonical = dir
-    }
-    if (seen.has(canonical)) continue
-    seen.add(canonical)
-    return dir
-  }
-  return null
-}
-
-function listChatFiles(geminiRoot: string): string[] {
-  const tmpDir = join(geminiRoot, 'tmp')
-  if (!existsSync(tmpDir)) return []
-
-  const files: string[] = []
-  for (const projectEntry of readdirSync(tmpDir, { withFileTypes: true })) {
-    if (!projectEntry.isDirectory()) continue
-    const chatsDir = join(tmpDir, projectEntry.name, 'chats')
-    if (!existsSync(chatsDir)) continue
-    for (const fileEntry of readdirSync(chatsDir, { withFileTypes: true })) {
-      if (fileEntry.isFile() && fileEntry.name.startsWith('session-') && fileEntry.name.endsWith('.json')) {
-        files.push(join(chatsDir, fileEntry.name))
-      }
-    }
-  }
-  return files
-}
-
-export const geminiCollector: Collector = {
-  id: 'gemini',
-  name: 'Gemini',
-
-  detect(homeDir: string): boolean {
-    const root = resolveGeminiRoot(homeDir)
-    return root != null && existsSync(join(root, 'tmp'))
-  },
-
-  collect(homeDir: string): RawSession[] {
-    const geminiRoot = resolveGeminiRoot(homeDir)
-    if (!geminiRoot) return []
-    const nameToPath = loadProjectNameMap(geminiRoot)
-
-    const sessions: RawSession[] = []
-    for (const filePath of listChatFiles(geminiRoot)) {
-      try {
-        if (!statSync(filePath).isFile()) continue
-        const projectDir = basename(dirname(dirname(filePath)))
-        const session = parseChatFile(filePath, projectDir, nameToPath)
-        if (session) sessions.push(session)
-      } catch {
-        continue
-      }
-    }
-    return sessions
-  },
-}

package/src/collectors/index.ts

@@ -1,20 +0,0 @@
-import { claudeCodeCollector } from './claude-code'
-import { codebuddyCollector } from './codebuddy'
-import { codexCollector } from './codex'
-import { cursorCollector } from './cursor'
-import { geminiCollector } from './gemini'
-import type { Collector } from './types'
-
-export const COLLECTORS: Collector[] = [
-  claudeCodeCollector,
-  codexCollector,
-  cursorCollector,
-  geminiCollector,
-  codebuddyCollector,
-]
-
-export function getCollector(id: string): Collector | null {
-  return COLLECTORS.find((collector) => collector.id === id) ?? null
-}
-
-export type { Collector, RawMessage, RawSession } from './types'

package/src/collectors/types.ts

@@ -1,22 +0,0 @@
-export interface RawMessage {
-  role: string
-  content: string
-  timestamp: string | null
-}
-
-export interface RawSession {
-  sourceSessionId: string
-  rawPath: string
-  rawProjectPath: string | null
-  title: string | null
-  createdAt: string | null
-  updatedAt: string | null
-  messages: RawMessage[]
-}
-
-export interface Collector {
-  id: string
-  name: string
-  detect(homeDir: string): boolean
-  collect(homeDir: string): RawSession[]
-}

package/src/collectors/util.ts

@@ -1,58 +0,0 @@
-import { tmpdir } from 'node:os'
-
-import type { RawMessage } from './types'
-
-const TITLE_MAX_LENGTH = 120
-
-const EPHEMERAL_PREFIXES = ['/tmp/', '/private/tmp/', '/var/folders/', '/private/var/folders/']
-
-export function isEphemeralPath(path: string | null): boolean {
-  if (!path) return false
-  const temp = tmpdir()
-  if (path === temp) return true
-  const normalized = path.endsWith('/') ? path : `${path}/`
-  const prefixes = [...EPHEMERAL_PREFIXES, `${temp}/`]
-  return prefixes.some((prefix) => normalized.startsWith(prefix))
-}
-
-export function clampTitle(value: string): string {
-  return value.length > TITLE_MAX_LENGTH ? `${value.slice(0, TITLE_MAX_LENGTH)}…` : value
-}
-
-function firstMeaningfulLine(content: string): string | null {
-  for (const line of content.split('\n')) {
-    const trimmed = line.trim()
-    if (trimmed === '' || /^[-=*#>`~]+$/.test(trimmed)) continue
-    return trimmed
-  }
-  return null
-}
-
-export function deriveTitle(messages: RawMessage[]): string | null {
-  for (const message of messages) {
-    if (message.role !== 'user') continue
-    const line = firstMeaningfulLine(message.content)
-    if (line) return clampTitle(line)
-  }
-  return null
-}
-
-export function normalizeContentParts(content: unknown): string {
-  if (typeof content === 'string') return content
-  if (Array.isArray(content)) {
-    return content
-      .map((part) => {
-        if (typeof part === 'string') return part
-        if (part && typeof part === 'object') {
-          const record = part as Record<string, unknown>
-          if (typeof record.text === 'string') return record.text
-          return JSON.stringify(record)
-        }
-        return String(part)
-      })
-      .join('\n')
-      .trim()
-  }
-  if (content == null) return ''
-  return JSON.stringify(content)
-}

package/src/compaction.ts

@@ -1,63 +0,0 @@
-import type { RawMessage } from './collectors'
-
-export interface CompactionOptions {
-  maxPerMessage: number
-  maxMessages: number
-}
-
-const DEFAULTS: CompactionOptions = {
-  maxPerMessage: 1200,
-  maxMessages: 60,
-}
-
-function squashWhitespace(text: string): string {
-  return text.replace(/[ \t]+\n/g, '\n').replace(/\n{3,}/g, '\n\n').trim()
-}
-
-function truncate(text: string, max: number): string {
-  const cleaned = squashWhitespace(text)
-  if (cleaned.length <= max) return cleaned
-  return `${cleaned.slice(0, max)}\n…[truncated ${cleaned.length - max} chars]`
-}
-
-export interface CompactMessageInput {
-  role: string
-  content: string
-}
-
-/**
- * Deterministic, dependency-free compaction. Keeps the head and tail of long
- * conversations and truncates oversized individual messages so the result is a
- * readable transcript that fits a token budget without calling any model.
- */
-export function compactTranscript(
-  messages: CompactMessageInput[],
-  options: Partial<CompactionOptions> = {},
-): string {
-  const opts = { ...DEFAULTS, ...options }
-  const meaningful = messages.filter((message) => message.content.trim() !== '')
-
-  let kept = meaningful
-  let omittedNote = ''
-  if (meaningful.length > opts.maxMessages) {
-    const head = Math.ceil(opts.maxMessages * 0.6)
-    const tail = opts.maxMessages - head
-    kept = [...meaningful.slice(0, head), ...meaningful.slice(meaningful.length - tail)]
-    omittedNote = `\n…[omitted ${meaningful.length - opts.maxMessages} middle messages]\n`
-  }
-
-  const lines: string[] = []
-  kept.forEach((message, index) => {
-    if (omittedNote && index === Math.ceil(opts.maxMessages * 0.6)) {
-      lines.push(omittedNote)
-    }
-    const label = message.role === 'user' ? 'User' : message.role === 'assistant' ? 'Assistant' : message.role
-    lines.push(`**${label}:** ${truncate(message.content, opts.maxPerMessage)}`)
-  })
-
-  return lines.join('\n\n')
-}
-
-export function compactRawMessages(messages: RawMessage[], options?: Partial<CompactionOptions>): string {
-  return compactTranscript(messages, options)
-}

package/src/config.ts

@@ -1,57 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-
-export interface LlmIwikiConfig {
-  obsidianVault: string | null
-}
-
-const KEY_ALIASES: Record<string, string> = {
-  'obsidian.vault': 'obsidian_vault',
-  obsidian_vault: 'obsidian_vault',
-}
-
-function parseToml(source: string): Record<string, string> {
-  const config: Record<string, string> = {}
-  for (const line of source.split('\n')) {
-    const trimmed = line.trim()
-    if (trimmed === '' || trimmed.startsWith('#') || trimmed.startsWith('[')) continue
-    const match = trimmed.match(/^([\w.]+)\s*=\s*(.*)$/)
-    if (!match) continue
-    const key = match[1]!
-    let value = match[2]!.trim()
-    if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
-      value = value.slice(1, -1)
-    }
-    config[key] = value
-  }
-  return config
-}
-
-export function readConfig(configFile: string): LlmIwikiConfig {
-  if (!existsSync(configFile)) return { obsidianVault: null }
-  const raw = parseToml(readFileSync(configFile, 'utf8'))
-  const vault = raw.obsidian_vault
-  return { obsidianVault: vault && vault.trim() !== '' ? vault : null }
-}
-
-export function setConfigValue(configFile: string, key: string, value: string): string {
-  const normalizedKey = KEY_ALIASES[key]
-  if (!normalizedKey) {
-    throw new Error(`Unknown config key: ${key}. Supported: obsidian.vault`)
-  }
-
-  const existing = existsSync(configFile) ? readFileSync(configFile, 'utf8') : ''
-  const lines = existing.split('\n')
-  const line = `${normalizedKey} = "${value}"`
-  let replaced = false
-  const next = lines.map((entry) => {
-    if (entry.trim().startsWith(`${normalizedKey} `) || entry.trim().startsWith(`${normalizedKey}=`)) {
-      replaced = true
-      return line
-    }
-    return entry
-  })
-  if (!replaced) next.push(line)
-
-  writeFileSync(configFile, `${next.filter((entry, index) => !(entry === '' && index === next.length - 1)).join('\n')}\n`)
-  return normalizedKey
-}

package/src/db.ts

@@ -1,152 +0,0 @@
-import { Database } from 'bun:sqlite'
-import { mkdirSync } from 'node:fs'
-import { dirname } from 'node:path'
-
-export type LlmIwikiDatabase = Database
-
-export function openDatabase(databaseFile: string): LlmIwikiDatabase {
-  mkdirSync(dirname(databaseFile), { recursive: true })
-  return new Database(databaseFile)
-}
-
-export function runMigrations(db: LlmIwikiDatabase): void {
-  db.exec(`
-    PRAGMA journal_mode = WAL;
-
-    CREATE TABLE IF NOT EXISTS projects (
-      id TEXT PRIMARY KEY,
-      canonical_name TEXT NOT NULL,
-      display_name TEXT,
-      slug TEXT NOT NULL,
-      canonical_repo_url TEXT,
-      provider TEXT,
-      identity_source TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS project_checkouts (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      local_path TEXT NOT NULL,
-      git_root TEXT,
-      remote_url TEXT,
-      canonical_remote_url TEXT,
-      current_branch TEXT,
-      first_seen_at TEXT NOT NULL,
-      last_seen_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS project_aliases (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      alias_type TEXT NOT NULL,
-      alias_value TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS sources (
-      id TEXT PRIMARY KEY,
-      name TEXT NOT NULL,
-      enabled INTEGER NOT NULL,
-      scan_paths TEXT,
-      config_json TEXT,
-      last_sync_at TEXT
-    );
-
-    CREATE TABLE IF NOT EXISTS sessions (
-      id TEXT PRIMARY KEY,
-      source_id TEXT NOT NULL,
-      source_session_id TEXT NOT NULL,
-      project_id TEXT,
-      checkout_id TEXT,
-      raw_project_path TEXT,
-      raw_path TEXT,
-      title TEXT,
-      message_count INTEGER NOT NULL,
-      content_hash TEXT NOT NULL,
-      status TEXT NOT NULL,
-      created_at TEXT,
-      updated_at TEXT,
-      first_seen_at TEXT NOT NULL,
-      last_seen_at TEXT NOT NULL,
-      UNIQUE(source_id, source_session_id, raw_path)
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_sessions_project ON sessions (project_id);
-
-    CREATE TABLE IF NOT EXISTS messages (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      role TEXT NOT NULL,
-      content TEXT NOT NULL,
-      timestamp TEXT,
-      tokens_in INTEGER DEFAULT 0,
-      tokens_out INTEGER DEFAULT 0,
-      seq_order INTEGER NOT NULL,
-      content_hash TEXT NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_messages_session ON messages (session_id);
-
-    CREATE TABLE IF NOT EXISTS session_summaries (
-      id TEXT PRIMARY KEY,
-      session_id TEXT NOT NULL,
-      project_id TEXT NOT NULL,
-      title TEXT NOT NULL,
-      value TEXT NOT NULL,
-      summary_markdown TEXT NOT NULL,
-      metadata_json TEXT,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS experience_candidates (
-      id TEXT PRIMARY KEY,
-      project_id TEXT NOT NULL,
-      proposed_title TEXT NOT NULL,
-      proposed_slug TEXT NOT NULL,
-      proposed_body_markdown TEXT NOT NULL,
-      source_sessions_json TEXT NOT NULL,
-      confidence TEXT,
-      status TEXT NOT NULL,
-      created_at TEXT NOT NULL
-    );
-
-    CREATE TABLE IF NOT EXISTS experiences (
-      id TEXT PRIMARY KEY,
-      project_id TEXT,
-      title TEXT NOT NULL,
-      slug TEXT NOT NULL,
-      problem_type TEXT,
-      solution_type TEXT,
-      tech_stack_json TEXT,
-      summary TEXT,
-      body_markdown TEXT NOT NULL,
-      confidence TEXT,
-      status TEXT NOT NULL,
-      created_at TEXT NOT NULL,
-      updated_at TEXT NOT NULL,
-      UNIQUE(project_id, slug)
-    );
-
-    CREATE TABLE IF NOT EXISTS session_experience_links (
-      session_id TEXT NOT NULL,
-      experience_id TEXT NOT NULL,
-      relation TEXT NOT NULL,
-      PRIMARY KEY (session_id, experience_id)
-    );
-
-    CREATE TABLE IF NOT EXISTS obsidian_notes (
-      id TEXT PRIMARY KEY,
-      note_type TEXT NOT NULL,
-      entity_id TEXT NOT NULL,
-      file_path TEXT NOT NULL,
-      managed_hash TEXT,
-      frontmatter_hash TEXT,
-      last_exported_at TEXT,
-      last_seen_mtime TEXT,
-      conflict_status TEXT NOT NULL,
-      UNIQUE(note_type, entity_id)
-    );
-  `)
-}