@codehourra/llm-iwiki 0.1.0

package/src/obsidian.ts

@@ -0,0 +1,345 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+
+import { stringify as stringifyYaml } from 'yaml'
+
+import type { LlmIwikiDatabase } from './db'
+import type { ProjectRecord } from './projects'
+
+const MANAGED_START = '<!-- aiwiki:managed:start -->'
+const MANAGED_END = '<!-- aiwiki:managed:end -->'
+
+export type NoteWriteStatus = 'created' | 'updated' | 'conflict' | 'forced'
+
+export interface NoteSpec {
+  noteType: string
+  entityId: string
+  relPath: string
+  frontmatter: Record<string, unknown>
+  title: string
+  managedBody: string
+  userSectionHeading?: string
+}
+
+export interface ExportOptions {
+  force: boolean
+}
+
+export interface ExportReport {
+  created: number
+  updated: number
+  forced: number
+  conflicts: string[]
+}
+
+function hash(value: string): string {
+  return Bun.hash(value).toString(16)
+}
+
+function sanitizeFileName(name: string): string {
+  const cleaned = name
+    .replace(/[\\/:*?"<>|]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 80)
+  return cleaned === '' ? 'untitled' : cleaned
+}
+
+function buildNote(spec: NoteSpec): string {
+  const frontmatter = stringifyYaml(spec.frontmatter).trimEnd()
+  const userHeading = spec.userSectionHeading ?? '## 我的补充'
+  return [
+    '---',
+    frontmatter,
+    '---',
+    '',
+    `# ${spec.title}`,
+    '',
+    MANAGED_START,
+    spec.managedBody.trim(),
+    MANAGED_END,
+    '',
+    userHeading,
+    '',
+    '',
+  ].join('\n')
+}
+
+interface ManagedSplit {
+  before: string
+  managed: string
+  after: string
+}
+
+function splitManaged(content: string): ManagedSplit | null {
+  const startIndex = content.indexOf(MANAGED_START)
+  const endIndex = content.indexOf(MANAGED_END)
+  if (startIndex === -1 || endIndex === -1 || endIndex < startIndex) return null
+  return {
+    before: content.slice(0, startIndex + MANAGED_START.length),
+    managed: content.slice(startIndex + MANAGED_START.length, endIndex).trim(),
+    after: content.slice(endIndex),
+  }
+}
+
+function replaceManaged(split: ManagedSplit, managedBody: string): string {
+  return `${split.before}\n${managedBody.trim()}\n${split.after}`
+}
+
+interface NoteRecord {
+  managed_hash: string | null
+  file_path: string
+}
+
+function getNoteRecord(db: LlmIwikiDatabase, noteType: string, entityId: string): NoteRecord | null {
+  return db
+    .query<NoteRecord, [string, string]>(
+      'SELECT managed_hash, file_path FROM obsidian_notes WHERE note_type = ? AND entity_id = ?',
+    )
+    .get(noteType, entityId)
+}
+
+function upsertNoteRecord(
+  db: LlmIwikiDatabase,
+  spec: NoteSpec,
+  filePath: string,
+  managedHash: string,
+  conflictStatus: string,
+  now: string,
+): void {
+  db.query(`
+    INSERT INTO obsidian_notes (id, note_type, entity_id, file_path, managed_hash, frontmatter_hash, last_exported_at, conflict_status)
+    VALUES ($id, $noteType, $entityId, $filePath, $managedHash, NULL, $now, $conflictStatus)
+    ON CONFLICT(note_type, entity_id) DO UPDATE SET
+      file_path = excluded.file_path,
+      managed_hash = excluded.managed_hash,
+      last_exported_at = excluded.last_exported_at,
+      conflict_status = excluded.conflict_status
+  `).run({
+    $id: `note_${hash(`${spec.noteType}\u0000${spec.entityId}`)}`,
+    $noteType: spec.noteType,
+    $entityId: spec.entityId,
+    $filePath: filePath,
+    $managedHash: managedHash,
+    $conflictStatus: conflictStatus,
+    $now: now,
+  })
+}
+
+export function writeNote(
+  db: LlmIwikiDatabase,
+  vault: string,
+  spec: NoteSpec,
+  options: ExportOptions,
+  now: string,
+): NoteWriteStatus {
+  const filePath = join(vault, spec.relPath)
+  const managedHash = hash(spec.managedBody.trim())
+
+  if (!existsSync(filePath)) {
+    mkdirSync(dirname(filePath), { recursive: true })
+    writeFileSync(filePath, buildNote(spec))
+    upsertNoteRecord(db, spec, filePath, managedHash, 'clean', now)
+    return 'created'
+  }
+
+  const existing = readFileSync(filePath, 'utf8')
+  const split = splitManaged(existing)
+  if (!split) {
+    upsertNoteRecord(db, spec, filePath, managedHash, 'no_managed_block', now)
+    return 'conflict'
+  }
+
+  const currentManagedHash = hash(split.managed)
+  const record = getNoteRecord(db, spec.noteType, spec.entityId)
+  const userEditedManaged = !record || record.managed_hash !== currentManagedHash
+
+  if (userEditedManaged && !options.force) {
+    upsertNoteRecord(db, spec, filePath, record?.managed_hash ?? currentManagedHash, 'managed_conflict', now)
+    return 'conflict'
+  }
+
+  writeFileSync(filePath, replaceManaged(split, spec.managedBody))
+  upsertNoteRecord(db, spec, filePath, managedHash, 'clean', now)
+  return userEditedManaged ? 'forced' : 'updated'
+}
+
+function projectDirName(project: ProjectRecord): string {
+  return sanitizeFileName(project.displayName ?? project.canonicalName ?? project.slug)
+}
+
+interface SummaryRow {
+  id: string
+  session_id: string
+  title: string
+  value: string
+  summary_markdown: string
+  updated_at: string | null
+}
+
+interface ExperienceRow {
+  id: string
+  title: string
+  slug: string
+  body_markdown: string
+  confidence: string | null
+  status: string
+  updated_at: string
+}
+
+export function exportProject(
+  db: LlmIwikiDatabase,
+  vault: string,
+  project: ProjectRecord,
+  options: ExportOptions,
+): ExportReport {
+  const now = new Date().toISOString()
+  const report: ExportReport = { created: 0, updated: 0, forced: 0, conflicts: [] }
+  const dirName = projectDirName(project)
+  const baseRel = join('LLM-iWiki', 'Projects', dirName)
+  const displayName = project.displayName ?? project.canonicalName
+
+  const track = (status: NoteWriteStatus, relPath: string): void => {
+    if (status === 'created') report.created += 1
+    else if (status === 'updated') report.updated += 1
+    else if (status === 'forced') report.forced += 1
+    else report.conflicts.push(relPath)
+  }
+
+  const summaries = db
+    .query<SummaryRow, [string]>(`
+      SELECT id, session_id, title, value, summary_markdown, updated_at
+      FROM session_summaries WHERE project_id = ? ORDER BY updated_at DESC
+    `)
+    .all(project.id)
+
+  for (const summary of summaries) {
+    const relPath = join(baseRel, 'Sessions', `${sanitizeFileName(summary.title)}.md`)
+    const spec: NoteSpec = {
+      noteType: 'session-summary',
+      entityId: summary.id,
+      relPath,
+      title: summary.title,
+      managedBody: summary.summary_markdown,
+      frontmatter: {
+        type: 'session-summary',
+        aiwiki_id: summary.id,
+        aiwiki_project_id: project.id,
+        project: displayName,
+        session_id: summary.session_id,
+        value: summary.value,
+        updated_at: summary.updated_at ?? now,
+      },
+    }
+    track(writeNote(db, vault, spec, options, now), relPath)
+  }
+
+  const experiences = db
+    .query<ExperienceRow, [string]>(`
+      SELECT id, title, slug, body_markdown, confidence, status, updated_at
+      FROM experiences WHERE project_id = ? AND status = 'accepted' ORDER BY updated_at DESC
+    `)
+    .all(project.id)
+
+  for (const experience of experiences) {
+    const relPath = join(baseRel, 'Experiences', `${sanitizeFileName(experience.slug || experience.title)}.md`)
+    const sourceSessions = db
+      .query<{ session_id: string }, [string]>(
+        'SELECT session_id FROM session_experience_links WHERE experience_id = ?',
+      )
+      .all(experience.id)
+      .map((row) => row.session_id)
+    const spec: NoteSpec = {
+      noteType: 'experience',
+      entityId: experience.id,
+      relPath,
+      title: experience.title,
+      managedBody: experience.body_markdown,
+      frontmatter: {
+        type: 'experience',
+        aiwiki_id: experience.id,
+        aiwiki_project_id: project.id,
+        project: displayName,
+        slug: experience.slug,
+        confidence: experience.confidence,
+        status: experience.status,
+        source_sessions: sourceSessions,
+        updated_at: experience.updated_at,
+      },
+    }
+    track(writeNote(db, vault, spec, options, now), relPath)
+  }
+
+  const indexRel = join(baseRel, 'Project Summary.md')
+  const indexBody = [
+    `- canonical: \`${project.canonicalName}\``,
+    project.canonicalRepoUrl ? `- repo: ${project.canonicalRepoUrl}` : null,
+    `- session summaries: ${summaries.length}`,
+    `- experiences: ${experiences.length}`,
+  ]
+    .filter((line): line is string => line != null)
+    .join('\n')
+  const indexSpec: NoteSpec = {
+    noteType: 'project-summary',
+    entityId: project.id,
+    relPath: indexRel,
+    title: displayName,
+    managedBody: indexBody,
+    frontmatter: {
+      type: 'project-summary',
+      aiwiki_project_id: project.id,
+      project: displayName,
+      canonical_repo_url: project.canonicalRepoUrl,
+      updated_at: now,
+    },
+  }
+  track(writeNote(db, vault, indexSpec, options, now), indexRel)
+
+  return report
+}
+
+export type CheckStatus = 'clean' | 'drift' | 'missing' | 'no_managed_block'
+
+export interface CheckEntry {
+  noteType: string
+  entityId: string
+  filePath: string
+  status: CheckStatus
+}
+
+export interface CheckReport {
+  total: number
+  clean: number
+  entries: CheckEntry[]
+}
+
+export function checkVault(db: LlmIwikiDatabase): CheckReport {
+  const rows = db
+    .query<{ note_type: string; entity_id: string; file_path: string; managed_hash: string | null }, []>(
+      'SELECT note_type, entity_id, file_path, managed_hash FROM obsidian_notes ORDER BY file_path ASC',
+    )
+    .all()
+
+  const entries: CheckEntry[] = []
+  let clean = 0
+
+  for (const row of rows) {
+    let status: CheckStatus
+    if (!existsSync(row.file_path)) {
+      status = 'missing'
+    } else {
+      const split = splitManaged(readFileSync(row.file_path, 'utf8'))
+      if (!split) {
+        status = 'no_managed_block'
+      } else if (row.managed_hash && hash(split.managed) === row.managed_hash) {
+        status = 'clean'
+      } else {
+        status = 'drift'
+      }
+    }
+    if (status === 'clean') clean += 1
+    else entries.push({ noteType: row.note_type, entityId: row.entity_id, filePath: row.file_path, status })
+  }
+
+  return { total: rows.length, clean, entries }
+}

package/src/paths.ts

@@ -0,0 +1,23 @@
+import { homedir } from 'node:os'
+import { join, resolve } from 'node:path'
+
+export interface AppPaths {
+  homeDir: string
+  configDir: string
+  configFile: string
+  databaseFile: string
+}
+
+export function getAppPaths(homeDir = homedir()): AppPaths {
+  const configDir = join(homeDir, '.llm-iwiki')
+  return {
+    homeDir,
+    configDir,
+    configFile: join(configDir, 'config.toml'),
+    databaseFile: join(configDir, 'llm-iwiki.db'),
+  }
+}
+
+export function getProjectTaskDir(cwd: string): string {
+  return resolve(cwd, '.llm-iwiki', 'tasks')
+}

package/src/projects.ts

@@ -0,0 +1,192 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { basename, resolve } from 'node:path'
+
+import type { LlmIwikiDatabase } from './db'
+
+export interface ProjectRecord {
+  id: string
+  canonicalName: string
+  displayName: string | null
+  slug: string
+  canonicalRepoUrl: string | null
+  identitySource: string
+}
+
+export function canonicalizeRemoteUrl(remoteUrl: string): string {
+  return remoteUrl
+    .trim()
+    .replace(/\/+$/, '')
+    .replace(/^ssh:\/\/git@([^/]+)\//, '$1/')
+    .replace(/^git@([^:]+):/, '$1/')
+    .replace(/^https?:\/\//, '')
+    .replace(/\.git$/, '')
+}
+
+export function slugifyProjectName(name: string): string {
+  const ascii = name
+    .normalize('NFKD')
+    .replace(/[^\w\s./-]/g, '')
+    .trim()
+    .toLowerCase()
+    .replace(/[\s._/]+/g, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '')
+
+  return ascii || 'project'
+}
+
+function git(cwd: string, args: string[]): string | null {
+  const result = spawnSync('git', args, { cwd, encoding: 'utf8' })
+  if (result.status !== 0) return null
+  return result.stdout.trim() || null
+}
+
+interface ProjectIdentity {
+  id: string
+  canonicalName: string
+  slug: string
+  canonicalRepoUrl: string | null
+  identitySource: string
+}
+
+function computeProjectIdentity(localPath: string): ProjectIdentity {
+  const gitRoot = git(localPath, ['rev-parse', '--show-toplevel'])
+  const remote = git(localPath, ['config', '--get', 'remote.origin.url'])
+  const canonicalRepoUrl = remote ? canonicalizeRemoteUrl(remote) : null
+  const canonicalName = canonicalRepoUrl ?? basename(gitRoot ?? localPath)
+  const slug = slugifyProjectName(canonicalName)
+  const id = `proj_${Bun.hash(canonicalRepoUrl ?? gitRoot ?? localPath).toString(16)}`
+
+  return {
+    id,
+    canonicalName,
+    slug,
+    canonicalRepoUrl,
+    identitySource: canonicalRepoUrl ? 'git_remote' : 'path',
+  }
+}
+
+function upsertProjectIdentity(db: LlmIwikiDatabase, identity: ProjectIdentity): ProjectRecord {
+  const now = new Date().toISOString()
+  db.query(`
+    INSERT INTO projects (id, canonical_name, display_name, slug, canonical_repo_url, provider, identity_source, created_at, updated_at)
+    VALUES ($id, $canonicalName, NULL, $slug, $canonicalRepoUrl, NULL, $identitySource, $now, $now)
+    ON CONFLICT(id) DO UPDATE SET
+      canonical_name = excluded.canonical_name,
+      slug = excluded.slug,
+      canonical_repo_url = excluded.canonical_repo_url,
+      identity_source = excluded.identity_source,
+      updated_at = excluded.updated_at
+  `).run({
+    $id: identity.id,
+    $canonicalName: identity.canonicalName,
+    $slug: identity.slug,
+    $canonicalRepoUrl: identity.canonicalRepoUrl,
+    $identitySource: identity.identitySource,
+    $now: now,
+  })
+
+  return getProject(db, identity.id)
+}
+
+export function resolveProject(db: LlmIwikiDatabase, checkoutPath: string): ProjectRecord {
+  const localPath = resolve(checkoutPath)
+  if (!existsSync(localPath)) throw new Error(`Path does not exist: ${localPath}`)
+  return upsertProjectIdentity(db, computeProjectIdentity(localPath))
+}
+
+export function resolveProjectByPath(db: LlmIwikiDatabase, rawPath: string): ProjectRecord {
+  const localPath = resolve(rawPath)
+  return upsertProjectIdentity(db, computeProjectIdentity(localPath))
+}
+
+export function renameProject(db: LlmIwikiDatabase, projectId: string, displayName: string): ProjectRecord {
+  const now = new Date().toISOString()
+  const changes = db
+    .query('UPDATE projects SET display_name = $displayName, updated_at = $now WHERE id = $projectId')
+    .run({
+      $displayName: displayName,
+      $projectId: projectId,
+      $now: now,
+    })
+
+  if (changes.changes === 0) throw new Error(`Project not found: ${projectId}`)
+
+  return getProject(db, projectId)
+}
+
+export interface ProjectSummaryRow extends ProjectRecord {
+  sessionCount: number
+  lastSeenAt: string | null
+}
+
+export function listProjects(db: LlmIwikiDatabase): ProjectSummaryRow[] {
+  const rows = db
+    .query<
+      {
+        id: string
+        canonical_name: string
+        display_name: string | null
+        slug: string
+        canonical_repo_url: string | null
+        identity_source: string
+        session_count: number
+        last_seen_at: string | null
+      },
+      []
+    >(`
+      SELECT
+        p.id,
+        p.canonical_name,
+        p.display_name,
+        p.slug,
+        p.canonical_repo_url,
+        p.identity_source,
+        COUNT(s.id) AS session_count,
+        MAX(s.last_seen_at) AS last_seen_at
+      FROM projects p
+      LEFT JOIN sessions s ON s.project_id = p.id
+      GROUP BY p.id
+      ORDER BY session_count DESC, p.canonical_name ASC
+    `)
+    .all()
+
+  return rows.map((row) => ({
+    id: row.id,
+    canonicalName: row.canonical_name,
+    displayName: row.display_name,
+    slug: row.slug,
+    canonicalRepoUrl: row.canonical_repo_url,
+    identitySource: row.identity_source,
+    sessionCount: row.session_count,
+    lastSeenAt: row.last_seen_at,
+  }))
+}
+
+export function getProject(db: LlmIwikiDatabase, projectId: string): ProjectRecord {
+  const row = db
+    .query<
+      {
+        id: string
+        canonical_name: string
+        display_name: string | null
+        slug: string
+        canonical_repo_url: string | null
+        identity_source: string
+      },
+      [string]
+    >('SELECT * FROM projects WHERE id = ?')
+    .get(projectId)
+
+  if (!row) throw new Error(`Project not found: ${projectId}`)
+
+  return {
+    id: row.id,
+    canonicalName: row.canonical_name,
+    displayName: row.display_name,
+    slug: row.slug,
+    canonicalRepoUrl: row.canonical_repo_url,
+    identitySource: row.identity_source,
+  }
+}

package/src/sessions.ts

@@ -0,0 +1,119 @@
+import type { LlmIwikiDatabase } from './db'
+
+export interface SessionRow {
+  id: string
+  sourceId: string
+  sourceSessionId: string
+  title: string | null
+  messageCount: number
+  status: string
+  rawProjectPath: string | null
+  updatedAt: string | null
+  lastSeenAt: string
+}
+
+export interface SourceBreakdown {
+  source: string
+  sessionCount: number
+}
+
+export interface ProjectInspection {
+  sources: SourceBreakdown[]
+  sessions: SessionRow[]
+}
+
+function mapRow(row: {
+  id: string
+  source_id: string
+  source_session_id: string
+  title: string | null
+  message_count: number
+  status: string
+  raw_project_path: string | null
+  updated_at: string | null
+  last_seen_at: string
+}): SessionRow {
+  return {
+    id: row.id,
+    sourceId: row.source_id,
+    sourceSessionId: row.source_session_id,
+    title: row.title,
+    messageCount: row.message_count,
+    status: row.status,
+    rawProjectPath: row.raw_project_path,
+    updatedAt: row.updated_at,
+    lastSeenAt: row.last_seen_at,
+  }
+}
+
+export function listSessionsByProject(db: LlmIwikiDatabase, projectId: string, limit = 100): SessionRow[] {
+  return db
+    .query<Parameters<typeof mapRow>[0], [string, number]>(`
+      SELECT id, source_id, source_session_id, title, message_count, status, raw_project_path, updated_at, last_seen_at
+      FROM sessions
+      WHERE project_id = ?
+      ORDER BY COALESCE(updated_at, last_seen_at) DESC
+      LIMIT ?
+    `)
+    .all(projectId, limit)
+    .map(mapRow)
+}
+
+export interface StoredMessage {
+  role: string
+  content: string
+}
+
+export function getSessionMessages(db: LlmIwikiDatabase, sessionId: string): StoredMessage[] {
+  return db
+    .query<{ role: string; content: string }, [string]>(
+      'SELECT role, content FROM messages WHERE session_id = ? ORDER BY seq_order ASC',
+    )
+    .all(sessionId)
+}
+
+export function getSession(db: LlmIwikiDatabase, sessionId: string): SessionRow | null {
+  const row = db
+    .query<Parameters<typeof mapRow>[0], [string]>(`
+      SELECT id, source_id, source_session_id, title, message_count, status, raw_project_path, updated_at, last_seen_at
+      FROM sessions
+      WHERE id = ?
+    `)
+    .get(sessionId)
+  return row ? mapRow(row) : null
+}
+
+export function listSessionsToSummarize(
+  db: LlmIwikiDatabase,
+  projectId: string,
+  scope: 'changed' | 'all',
+): SessionRow[] {
+  const statusClause = scope === 'changed' ? "AND status IN ('new', 'changed')" : ''
+  return db
+    .query<Parameters<typeof mapRow>[0], [string]>(`
+      SELECT id, source_id, source_session_id, title, message_count, status, raw_project_path, updated_at, last_seen_at
+      FROM sessions
+      WHERE project_id = ? ${statusClause}
+      ORDER BY COALESCE(updated_at, last_seen_at) DESC
+    `)
+    .all(projectId)
+    .map(mapRow)
+}
+
+export function inspectProject(db: LlmIwikiDatabase, projectId: string): ProjectInspection {
+  const sources = db
+    .query<{ source_id: string; session_count: number }, [string]>(`
+      SELECT source_id, COUNT(*) AS session_count
+      FROM sessions
+      WHERE project_id = ?
+      GROUP BY source_id
+      ORDER BY session_count DESC
+    `)
+    .all(projectId)
+    .map((row) => ({ source: row.source_id, sessionCount: row.session_count }))
+
+  return {
+    sources,
+    sessions: listSessionsByProject(db, projectId),
+  }
+}