contextgit 0.0.1 → 0.0.2

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

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

@@ -0,0 +1,99 @@
+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())
+    })()
+  }
+}