contextgit 0.0.2 → 0.0.3

package/packages/store/src/local/local-store.test.ts

@@ -1,164 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { LocalStore } from './index.js'
-
-describe('LocalStore (in-memory)', () => {
-  let store: LocalStore
-
-  beforeEach(() => {
-    store = new LocalStore(':memory:')
-  })
-
-  afterEach(() => {
-    store.close()
-  })
-
-  it('creates and retrieves a project', async () => {
-    const project = await store.createProject({ name: 'test-project', description: 'A test' })
-    expect(project.id).toBeTruthy()
-    expect(project.name).toBe('test-project')
-
-    const fetched = await store.getProject(project.id)
-    expect(fetched).toBeTruthy()
-    expect(fetched!.name).toBe('test-project')
-  })
-
-  it('creates and retrieves a branch', async () => {
-    const project = await store.createProject({ name: 'p' })
-    const branch = await store.createBranch({
-      projectId: project.id,
-      name: 'main',
-      gitBranch: 'main',
-    })
-    expect(branch.id).toBeTruthy()
-    expect(branch.gitBranch).toBe('main')
-
-    const byGit = await store.getBranchByGitName(project.id, 'main')
-    expect(byGit!.id).toBe(branch.id)
-  })
-
-  it('creates a commit, opens a thread, closes it', async () => {
-    const project = await store.createProject({ name: 'p' })
-    const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    // Upsert agent first (required for commit attribution)
-    await store.upsertAgent({
-      id: 'agent-1',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'claude-code',
-      workflowType: 'interactive',
-    })
-
-    const commit1 = await store.createCommit({
-      branchId: branch.id,
-      agentId: 'agent-1',
-      agentRole: 'dev',
-      tool: 'claude-code',
-      workflowType: 'interactive',
-      message: 'Initial commit',
-      content: 'Set up project structure',
-      summary: 'Project scaffolded',
-      commitType: 'manual',
-      threads: { open: ['Authentication approach not decided'] },
-    })
-    expect(commit1.id).toBeTruthy()
-    expect(commit1.message).toBe('Initial commit')
-
-    // Thread should be open
-    const openThreads = await store.listOpenThreads(project.id)
-    expect(openThreads).toHaveLength(1)
-    expect(openThreads[0].description).toBe('Authentication approach not decided')
-    const threadId = openThreads[0].id
-
-    // Second commit closes the thread
-    const commit2 = await store.createCommit({
-      branchId: branch.id,
-      agentId: 'agent-1',
-      agentRole: 'dev',
-      tool: 'claude-code',
-      workflowType: 'interactive',
-      message: 'Choose JWT auth',
-      content: 'Implemented JWT RS256',
-      summary: 'JWT RS256 chosen, implemented',
-      commitType: 'manual',
-      threads: { close: [{ id: threadId, note: 'Using JWT RS256' }] },
-    })
-    expect(commit2.id).toBeTruthy()
-
-    const stillOpen = await store.listOpenThreads(project.id)
-    expect(stillOpen).toHaveLength(0)
-  })
-
-  it('getSessionSnapshot returns project/branch summaries and threads', async () => {
-    const project = await store.createProject({ name: 'snap-test' })
-    const main = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    const feature = await store.createBranch({
-      projectId: project.id,
-      name: 'feature/auth',
-      gitBranch: 'feature/auth',
-      parentBranchId: main.id,
-    })
-
-    await store.upsertAgent({ id: 'ag', projectId: project.id, role: 'dev', tool: 'cli', workflowType: 'interactive' })
-
-    await store.createCommit({
-      branchId: main.id, agentId: 'ag', agentRole: 'dev', tool: 'cli',
-      workflowType: 'interactive', message: 'main commit', content: 'content',
-      summary: 'Main branch summary', commitType: 'manual',
-    })
-    await store.createCommit({
-      branchId: feature.id, agentId: 'ag', agentRole: 'dev', tool: 'cli',
-      workflowType: 'interactive', message: 'feature commit', content: 'feature content',
-      summary: 'Feature branch summary', commitType: 'manual',
-      threads: { open: ['Open thread on feature'] },
-    })
-
-    const snapshot = await store.getSessionSnapshot(project.id, feature.id)
-    expect(snapshot.projectSummary).toBe('Main branch summary')
-    expect(snapshot.branchSummary).toBe('Feature branch summary')
-    expect(snapshot.branchName).toBe('feature/auth')
-    expect(snapshot.recentCommits).toHaveLength(1)
-    expect(snapshot.openThreads).toHaveLength(1)
-    expect(snapshot.openThreads[0].description).toBe('Open thread on feature')
-  })
-
-  it('getFormattedSnapshot returns text format', async () => {
-    const project = await store.createProject({ name: 'fmt-test' })
-    const branch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    const text = await store.getFormattedSnapshot(project.id, branch.id, 'text')
-    expect(text).toContain('=== PROJECT STATE ===')
-    expect(text).toContain('=== CURRENT BRANCH: main ===')
-    expect(text).toContain('=== OPEN THREADS ===')
-  })
-
-  it('mergeBranch carries open threads to target and marks source merged', async () => {
-    const project = await store.createProject({ name: 'merge-test' })
-    const main = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    const feat = await store.createBranch({ projectId: project.id, name: 'feat', gitBranch: 'feat', parentBranchId: main.id })
-
-    await store.upsertAgent({ id: 'ag', projectId: project.id, role: 'dev', tool: 'cli', workflowType: 'interactive' })
-
-    await store.createCommit({
-      branchId: main.id, agentId: 'ag', agentRole: 'dev', tool: 'cli',
-      workflowType: 'interactive', message: 'main init', content: 'c', summary: 's', commitType: 'branch-init',
-    })
-    await store.createCommit({
-      branchId: feat.id, agentId: 'ag', agentRole: 'dev', tool: 'cli',
-      workflowType: 'interactive', message: 'feat work', content: 'c', summary: 's', commitType: 'manual',
-      threads: { open: ['Thread from feat'] },
-    })
-
-    const mergeCommit = await store.mergeBranch(feat.id, main.id, 'Merged feat into main')
-    expect(mergeCommit.commitType).toBe('merge')
-    expect(mergeCommit.branchId).toBe(main.id)
-
-    // Source branch is merged
-    const updatedFeat = await store.getBranch(feat.id)
-    expect(updatedFeat!.status).toBe('merged')
-
-    // Thread carried to main
-    const mainThreads = await store.listOpenThreadsByBranch(main.id)
-    expect(mainThreads).toHaveLength(1)
-    expect(mainThreads[0].description).toBe('Thread from feat')
-  })
-})

package/packages/store/src/local/migrations.ts

@@ -1,99 +0,0 @@
-import type { Database } from 'better-sqlite3'
-import { SCHEMA_V1_DDL, SCHEMA_V2_DDL, SCHEMA_V3_DDL, SCHEMA_V4_DDL, CREATE_COMMIT_EMBEDDINGS } from './schema.js'
-
-interface MigrationRow {
-  version: number
-  name: string
-  applied_at: number
-}
-
-const MIGRATIONS_TABLE = `
-CREATE TABLE IF NOT EXISTS _migrations (
-  version    INTEGER PRIMARY KEY,
-  name       TEXT NOT NULL,
-  applied_at INTEGER NOT NULL
-)
-`
-
-interface Migration {
-  version: number
-  name: string
-  run(db: Database): void
-}
-
-const MIGRATIONS: Migration[] = [
-  {
-    version: 1,
-    name: 'initial_schema',
-    run(db) {
-      for (const sql of SCHEMA_V1_DDL) {
-        db.exec(sql)
-      }
-    },
-  },
-  {
-    version: 2,
-    name: 'fts5_and_vectors',
-    run(db) {
-      // FTS5 full-text index
-      for (const sql of SCHEMA_V2_DDL) {
-        db.exec(sql)
-      }
-
-      // sqlite-vec virtual table — optional, skipped if extension not loaded
-      try {
-        db.exec(CREATE_COMMIT_EMBEDDINGS)
-      } catch {
-        // sqlite-vec not loaded; semantic search will return empty results
-      }
-    },
-  },
-  {
-    version: 3,
-    name: 'fts_trigger',
-    run(db) {
-      // Add INSERT trigger to keep commits_fts in sync with commits table.
-      // Then rebuild the index to pick up any rows inserted before this migration.
-      for (const sql of SCHEMA_V3_DDL) {
-        db.exec(sql)
-      }
-      try {
-        db.exec(`INSERT INTO commits_fts(commits_fts) VALUES('rebuild')`)
-      } catch {
-        // FTS5 table not available — skip rebuild
-      }
-    },
-  },
-  {
-    version: 4,
-    name: 'claims_table',
-    run(db) {
-      for (const sql of SCHEMA_V4_DDL) {
-        db.exec(sql)
-      }
-    },
-  },
-]
-
-export function runMigrations(db: Database): void {
-  // Ensure migrations table exists
-  db.exec(MIGRATIONS_TABLE)
-
-  const getApplied = db.prepare<[], MigrationRow>(
-    'SELECT version, name, applied_at FROM _migrations ORDER BY version'
-  )
-  const insertMigration = db.prepare(
-    'INSERT INTO _migrations (version, name, applied_at) VALUES (?, ?, ?)'
-  )
-
-  const applied = new Set(getApplied.all().map((r) => r.version))
-
-  for (const migration of MIGRATIONS) {
-    if (applied.has(migration.version)) continue
-
-    db.transaction(() => {
-      migration.run(db)
-      insertMigration.run(migration.version, migration.name, Date.now())
-    })()
-  }
-}