@codehourra/llm-iwiki 0.1.0 → 0.1.1

package/src/experiences.ts

@@ -1,235 +0,0 @@
-import type { ParsedExperiencesYaml } from './types'
-import type { LlmIwikiDatabase } from './db'
-import { slugifyProjectName } from './projects'
-
-export type ExperienceScope = 'changed-summaries' | 'all-recent'
-
-export interface PrepareExperiencesResult {
-  markdown: string
-  summaryCount: number
-}
-
-interface SummaryRow {
-  session_id: string
-  title: string
-  value: string
-  summary_markdown: string
-}
-
-const EXPERIENCES_FORMAT = `## 输出格式
-
-基于下面这些会话摘要，提炼出可复用的项目经验，生成 \`experiences.yaml\` 写入
-\`.llm-iwiki/tasks/experiences.yaml\`，再运行 \`llm-iwiki experiences propose\`。
-
-\`\`\`yaml
-project_id: <见下方 project_id>
-experiences:
-  - title: <经验标题>
-    slug: <可选，稳定短标识>
-    summary: |
-      一句话说明这条经验。
-    body_markdown: |
-      ## 背景
-      ## 方案
-      ## 结论
-    source_sessions:
-      - <相关 session_id>
-    confidence: low | medium | high
-\`\`\`
-
-要求：
-- 一条经验可以聚合多个会话，按主题归纳，不要逐会话复述。
-- \`source_sessions\` 填写该经验来自哪些 session_id。`
-
-function fetchSummaries(db: LlmIwikiDatabase, projectId: string, scope: ExperienceScope): SummaryRow[] {
-  const valueClause = scope === 'changed-summaries' ? "AND value IN ('medium', 'high')" : ''
-  return db
-    .query<SummaryRow, [string]>(`
-      SELECT session_id, title, value, summary_markdown
-      FROM session_summaries
-      WHERE project_id = ? ${valueClause}
-      ORDER BY updated_at DESC
-    `)
-    .all(projectId)
-}
-
-export function prepareExperiencesTask(
-  db: LlmIwikiDatabase,
-  projectId: string,
-  scope: ExperienceScope,
-): PrepareExperiencesResult {
-  const summaries = fetchSummaries(db, projectId, scope)
-
-  const blocks = summaries.map((summary) =>
-    [`### ${summary.session_id} — ${summary.title}`, `- value: ${summary.value}`, '', summary.summary_markdown].join('\n'),
-  )
-
-  const markdown = [
-    `# Experiences Task`,
-    '',
-    `project_id: ${projectId}`,
-    `scope: ${scope}`,
-    `summaries: ${blocks.length}`,
-    '',
-    EXPERIENCES_FORMAT,
-    '',
-    '---',
-    '',
-    blocks.join('\n\n---\n\n'),
-    '',
-  ].join('\n')
-
-  return { markdown, summaryCount: blocks.length }
-}
-
-export interface ProposeExperiencesResult {
-  written: number
-}
-
-function hash(value: string): string {
-  return Bun.hash(value).toString(16)
-}
-
-export function proposeExperiences(db: LlmIwikiDatabase, parsed: ParsedExperiencesYaml): ProposeExperiencesResult {
-  const now = new Date().toISOString()
-  let written = 0
-
-  const propose = db.transaction(() => {
-    for (const experience of parsed.experiences) {
-      const slug = experience.slug && experience.slug.trim() !== '' ? experience.slug : slugifyProjectName(experience.title)
-      const id = `cand_${hash(`${parsed.projectId}\u0000${slug}`)}`
-
-      db.query(`
-        INSERT INTO experience_candidates (
-          id, project_id, proposed_title, proposed_slug, proposed_body_markdown, source_sessions_json, confidence, status, created_at
-        ) VALUES ($id, $projectId, $title, $slug, $body, $sources, $confidence, 'proposed', $now)
-        ON CONFLICT(id) DO UPDATE SET
-          proposed_title = excluded.proposed_title,
-          proposed_body_markdown = excluded.proposed_body_markdown,
-          source_sessions_json = excluded.source_sessions_json,
-          confidence = excluded.confidence
-      `).run({
-        $id: id,
-        $projectId: parsed.projectId,
-        $title: experience.title,
-        $slug: slug,
-        $body: experience.bodyMarkdown,
-        $sources: JSON.stringify(experience.sourceSessions),
-        $confidence: experience.confidence,
-        $now: now,
-      })
-      written += 1
-    }
-  })
-  propose()
-
-  return { written }
-}
-
-export interface CandidateRow {
-  id: string
-  project_id: string
-  proposed_title: string
-  proposed_slug: string
-  confidence: string | null
-  status: string
-  source_sessions_json: string
-  created_at: string
-}
-
-export function listCandidates(db: LlmIwikiDatabase, projectId: string | null): CandidateRow[] {
-  if (projectId) {
-    return db
-      .query<CandidateRow, [string]>(
-        'SELECT id, project_id, proposed_title, proposed_slug, confidence, status, source_sessions_json, created_at FROM experience_candidates WHERE project_id = ? ORDER BY created_at DESC',
-      )
-      .all(projectId)
-  }
-  return db
-    .query<CandidateRow, []>(
-      'SELECT id, project_id, proposed_title, proposed_slug, confidence, status, source_sessions_json, created_at FROM experience_candidates ORDER BY created_at DESC',
-    )
-    .all()
-}
-
-export interface AcceptExperienceResult {
-  experienceId: string
-  slug: string
-  linkedSessions: number
-}
-
-export function acceptExperience(db: LlmIwikiDatabase, candidateId: string): AcceptExperienceResult {
-  const candidate = db
-    .query<
-      {
-        project_id: string
-        proposed_title: string
-        proposed_slug: string
-        proposed_body_markdown: string
-        confidence: string | null
-        source_sessions_json: string
-      },
-      [string]
-    >(
-      'SELECT project_id, proposed_title, proposed_slug, proposed_body_markdown, confidence, source_sessions_json FROM experience_candidates WHERE id = ?',
-    )
-    .get(candidateId)
-
-  if (!candidate) throw new Error(`Experience candidate not found: ${candidateId}`)
-
-  let sourceSessions: string[] = []
-  try {
-    const parsed = JSON.parse(candidate.source_sessions_json) as unknown
-    if (Array.isArray(parsed)) sourceSessions = parsed.filter((value): value is string => typeof value === 'string')
-  } catch {
-    sourceSessions = []
-  }
-
-  const now = new Date().toISOString()
-  const experienceId = `exp_${hash(`${candidate.project_id}\u0000${candidate.proposed_slug}`)}`
-
-  const accept = db.transaction(() => {
-    db.query(`
-      INSERT INTO experiences (
-        id, project_id, title, slug, body_markdown, confidence, status, created_at, updated_at
-      ) VALUES ($id, $projectId, $title, $slug, $body, $confidence, 'accepted', $now, $now)
-      ON CONFLICT(project_id, slug) DO UPDATE SET
-        title = excluded.title,
-        body_markdown = excluded.body_markdown,
-        confidence = excluded.confidence,
-        status = 'accepted',
-        updated_at = excluded.updated_at
-    `).run({
-      $id: experienceId,
-      $projectId: candidate.project_id,
-      $title: candidate.proposed_title,
-      $slug: candidate.proposed_slug,
-      $body: candidate.proposed_body_markdown,
-      $confidence: candidate.confidence,
-      $now: now,
-    })
-
-    const resolved = db
-      .query<{ id: string }, [string, string]>('SELECT id FROM experiences WHERE project_id = ? AND slug = ?')
-      .get(candidate.project_id, candidate.proposed_slug)
-    const finalId = resolved?.id ?? experienceId
-
-    for (const sessionId of sourceSessions) {
-      db.query(`
-        INSERT INTO session_experience_links (session_id, experience_id, relation)
-        VALUES (?, ?, 'source')
-        ON CONFLICT(session_id, experience_id) DO NOTHING
-      `).run(sessionId, finalId)
-    }
-
-    db.query("UPDATE experience_candidates SET status = 'accepted' WHERE id = ?").run(candidateId)
-  })
-  accept()
-
-  return { experienceId, slug: candidate.proposed_slug, linkedSessions: sourceSessions.length }
-}
-
-export function rejectExperience(db: LlmIwikiDatabase, candidateId: string): void {
-  const changes = db.query("UPDATE experience_candidates SET status = 'rejected' WHERE id = ?").run(candidateId)
-  if (changes.changes === 0) throw new Error(`Experience candidate not found: ${candidateId}`)
-}

package/src/index.ts

@@ -1,10 +0,0 @@
-#!/usr/bin/env bun
-import { runCli } from './cli'
-
-const exitCode = await runCli(process.argv.slice(2), {
-  cwd: process.cwd(),
-  stdout: console.log,
-  stderr: console.error,
-})
-
-process.exit(exitCode)

package/src/obsidian.ts

@@ -1,345 +0,0 @@
-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

@@ -1,23 +0,0 @@
-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')
-}