contextgit 0.0.2 → 0.0.3

package/packages/store/src/interface.ts

@@ -1,62 +0,0 @@
-import type {
-  Agent,
-  AgentInput,
-  AgentRole,
-  Branch,
-  BranchInput,
-  Claim,
-  ClaimInput,
-  Commit,
-  CommitInput,
-  Pagination,
-  Project,
-  ProjectInput,
-  SearchResult,
-  SessionSnapshot,
-  SnapshotFormat,
-  Thread,
-} from '@contextgit/core'
-
-export interface ContextStore {
-  // Projects
-  createProject(project: ProjectInput): Promise<Project>
-  getProject(id: string): Promise<Project | null>
-
-  // Branches
-  createBranch(branch: BranchInput): Promise<Branch>
-  getBranch(id: string): Promise<Branch | null>
-  getBranchByGitName(projectId: string, gitBranch: string): Promise<Branch | null>
-  listBranches(projectId: string): Promise<Branch[]>
-  updateBranchHead(branchId: string, commitId: string): Promise<void>
-  mergeBranch(sourceBranchId: string, targetBranchId: string, summary: string): Promise<Commit>
-
-  // Commits
-  createCommit(commit: CommitInput): Promise<Commit>
-  getCommit(id: string): Promise<Commit | null>
-  listCommits(branchId: string, pagination: Pagination): Promise<Commit[]>
-
-  // Snapshots
-  getSessionSnapshot(projectId: string, branchId: string, options?: { agentRole?: AgentRole }): Promise<SessionSnapshot>
-  getFormattedSnapshot(projectId: string, branchId: string, format: SnapshotFormat): Promise<string>
-
-  // Threads
-  listOpenThreads(projectId: string): Promise<Thread[]>
-  listOpenThreadsByBranch(branchId: string): Promise<Thread[]>
-  syncThread(thread: Thread): Promise<Thread>
-
-  // Search
-  // vector is a 384-dim Float32Array produced by EmbeddingService in core.
-  // Callers that cannot generate a vector should skip this and use fullTextSearch.
-  indexEmbedding(commitId: string, vector: Float32Array): Promise<void>
-  semanticSearch(vector: Float32Array, projectId: string, limit: number): Promise<SearchResult[]>
-  fullTextSearch(query: string, projectId: string): Promise<SearchResult[]>
-
-  // Agents
-  upsertAgent(agent: AgentInput): Promise<Agent>
-  listAgents(projectId: string): Promise<Agent[]>
-
-  // Claims
-  claimTask(projectId: string, branchId: string, input: ClaimInput): Promise<Claim>
-  unclaimTask(claimId: string): Promise<void>
-  listActiveClaims(projectId: string): Promise<Claim[]>
-}

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

@@ -1,190 +0,0 @@
-import { describe, it, expect, afterEach } from 'vitest'
-import { LocalStore } from './index.js'
-
-// Helpers to set up a minimal project + branch
-async function setupStore() {
-  const store = new LocalStore(':memory:')
-  const project = await store.createProject({ name: 'test-project' })
-  const branch = await store.createBranch({
-    projectId: project.id,
-    name: 'main',
-    gitBranch: 'main',
-  })
-  return { store, project, branch }
-}
-
-describe('claimTask', () => {
-  afterEach(() => {
-    // stores are :memory: — closed per test via store.close()
-  })
-
-  it('creates a claim with correct fields', async () => {
-    const { store, project, branch } = await setupStore()
-
-    const claim = await store.claimTask(project.id, branch.id, {
-      task: 'build auth module',
-      agentId: 'agent-1',
-      role: 'dev',
-    })
-
-    expect(claim.id).toBeTruthy()
-    expect(claim.projectId).toBe(project.id)
-    expect(claim.branchId).toBe(branch.id)
-    expect(claim.task).toBe('build auth module')
-    expect(claim.agentId).toBe('agent-1')
-    expect(claim.role).toBe('dev')
-    expect(claim.status).toBe('proposed')
-    expect(claim.ttl).toBe(7_200_000)
-    expect(claim.claimedAt).toBeInstanceOf(Date)
-    expect(claim.releasedAt).toBeUndefined()
-
-    store.close()
-  })
-
-  it('respects custom status and ttl', async () => {
-    const { store, project, branch } = await setupStore()
-
-    const claim = await store.claimTask(project.id, branch.id, {
-      task: 'write tests',
-      agentId: 'agent-2',
-      role: 'test',
-      status: 'active',
-      ttl: 3_600_000, // 1h
-    })
-
-    expect(claim.status).toBe('active')
-    expect(claim.ttl).toBe(3_600_000)
-
-    store.close()
-  })
-})
-
-describe('listActiveClaims', () => {
-  it('returns proposed and active claims', async () => {
-    const { store, project, branch } = await setupStore()
-
-    await store.claimTask(project.id, branch.id, { task: 'task-a', agentId: 'agent-1', role: 'dev', status: 'proposed' })
-    await store.claimTask(project.id, branch.id, { task: 'task-b', agentId: 'agent-2', role: 'test', status: 'active' })
-
-    const claims = await store.listActiveClaims(project.id)
-    expect(claims).toHaveLength(2)
-
-    store.close()
-  })
-
-  it('excludes released claims', async () => {
-    const { store, project, branch } = await setupStore()
-
-    const c1 = await store.claimTask(project.id, branch.id, { task: 'task-a', agentId: 'agent-1', role: 'dev' })
-    await store.claimTask(project.id, branch.id, { task: 'task-b', agentId: 'agent-2', role: 'dev' })
-    await store.unclaimTask(c1.id)
-
-    const claims = await store.listActiveClaims(project.id)
-    expect(claims).toHaveLength(1)
-    expect(claims[0].task).toBe('task-b')
-
-    store.close()
-  })
-
-  it('excludes TTL-expired claims', async () => {
-    const { store, project, branch } = await setupStore()
-
-    // Create a claim with 1ms TTL (already expired)
-    await store.claimTask(project.id, branch.id, { task: 'expired', agentId: 'agent-1', role: 'dev', ttl: 1 })
-    // Wait a tick to ensure the TTL has elapsed
-    await new Promise((r) => setTimeout(r, 10))
-    await store.claimTask(project.id, branch.id, { task: 'active', agentId: 'agent-2', role: 'dev', ttl: 7_200_000 })
-
-    const claims = await store.listActiveClaims(project.id)
-    expect(claims).toHaveLength(1)
-    expect(claims[0].task).toBe('active')
-
-    store.close()
-  })
-})
-
-describe('unclaimTask', () => {
-  it('sets status to released and sets releasedAt', async () => {
-    const { store, project, branch } = await setupStore()
-
-    const claim = await store.claimTask(project.id, branch.id, { task: 'do work', agentId: 'agent-1', role: 'solo' })
-    await store.unclaimTask(claim.id)
-
-    const active = await store.listActiveClaims(project.id)
-    expect(active).toHaveLength(0)
-
-    store.close()
-  })
-})
-
-describe('createCommit auto-release', () => {
-  it('releases this agent\'s claims on this branch after commit', async () => {
-    const { store, project, branch } = await setupStore()
-
-    await store.claimTask(project.id, branch.id, { task: 'my task', agentId: 'agent-1', role: 'dev' })
-    // Second agent's claim should NOT be released
-    await store.claimTask(project.id, branch.id, { task: 'other task', agentId: 'agent-2', role: 'dev' })
-
-    await store.createCommit({
-      branchId: branch.id,
-      agentId: 'agent-1',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'done',
-      content: 'finished',
-      summary: 'finished',
-      commitType: 'manual',
-    })
-
-    const remaining = await store.listActiveClaims(project.id)
-    expect(remaining).toHaveLength(1)
-    expect(remaining[0].agentId).toBe('agent-2')
-
-    store.close()
-  })
-
-  it('does not release claims on other branches', async () => {
-    const { store, project, branch } = await setupStore()
-    const otherBranch = await store.createBranch({
-      projectId: project.id,
-      name: 'feature',
-      gitBranch: 'feature/x',
-    })
-
-    // agent-1 has a claim on the other branch
-    await store.claimTask(project.id, otherBranch.id, { task: 'other branch task', agentId: 'agent-1', role: 'dev' })
-
-    await store.createCommit({
-      branchId: branch.id,
-      agentId: 'agent-1',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'commit on main',
-      content: 'work',
-      summary: 'work',
-      commitType: 'manual',
-    })
-
-    const remaining = await store.listActiveClaims(project.id)
-    expect(remaining).toHaveLength(1)
-    expect(remaining[0].task).toBe('other branch task')
-
-    store.close()
-  })
-})
-
-describe('snapshot activeClaims', () => {
-  it('includes active claims in session snapshot', async () => {
-    const { store, project, branch } = await setupStore()
-
-    await store.claimTask(project.id, branch.id, { task: 'build feature', agentId: 'agent-1', role: 'dev' })
-
-    const snapshot = await store.getSessionSnapshot(project.id, branch.id)
-    expect(snapshot.activeClaims).toHaveLength(1)
-    expect(snapshot.activeClaims[0].task).toBe('build feature')
-
-    store.close()
-  })
-})

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

@@ -1,380 +0,0 @@
-// LocalStore — better-sqlite3 + sqlite-vec implementation of ContextStore.
-//
-// Key invariants:
-//   • All SQLite calls are synchronous (better-sqlite3).
-//   • The ContextStore interface returns Promises, so we wrap at the boundary
-//     with Promise.resolve() / Promise.reject().
-//   • IDs are nanoid() TEXT — never auto-increment integers.
-//   • DB path: ~/.contextgit/projects/<projectId>.db
-
-import { homedir } from 'os'
-import { mkdirSync } from 'fs'
-import { join } from 'path'
-import { createRequire } from 'module'
-import Database from 'better-sqlite3'
-import { nanoid } from 'nanoid'
-
-const require = createRequire(import.meta.url)
-import type {
-  Agent,
-  AgentInput,
-  Branch,
-  BranchInput,
-  Claim,
-  ClaimInput,
-  Commit,
-  CommitInput,
-  Pagination,
-  Project,
-  ProjectInput,
-  SearchResult,
-  SessionSnapshot,
-  SnapshotFormat,
-  Thread,
-} from '@contextgit/core'
-import { SnapshotFormatter } from '@contextgit/core'
-import type { ContextStore } from '../interface.js'
-import { runMigrations } from './migrations.js'
-import { Queries } from './queries.js'
-
-const snapshotFormatter = new SnapshotFormatter()
-
-// ─── LocalStore ───────────────────────────────────────────────────────────────
-
-export class LocalStore implements ContextStore {
-  private readonly db: Database.Database
-  private readonly q: Queries
-
-  /**
-   * @param projectId  Used to derive the DB file path.
-   *                   Pass ':memory:' for tests.
-   */
-  constructor(projectId: string) {
-    let dbPath: string
-    if (projectId === ':memory:') {
-      dbPath = ':memory:'
-    } else {
-      const dir = join(homedir(), '.contextgit', 'projects')
-      mkdirSync(dir, { recursive: true })
-      dbPath = join(dir, `${projectId}.db`)
-    }
-
-    this.db = new Database(dbPath)
-    this.db.pragma('journal_mode = WAL')
-    this.db.pragma('busy_timeout = 5000')
-    this.db.pragma('foreign_keys = ON')
-
-    // Attempt to load sqlite-vec extension — graceful failure if not available
-    try {
-      const sqliteVec = require('sqlite-vec') as { load: (db: Database.Database) => void }
-      sqliteVec.load(this.db)
-    } catch {
-      // sqlite-vec not installed or ABI mismatch — semantic search disabled
-    }
-
-    runMigrations(this.db)
-    this.q = new Queries(this.db)
-  }
-
-  // ─── Projects ─────────────────────────────────────────────────────────────
-
-  createProject(project: ProjectInput): Promise<Project> {
-    try {
-      return Promise.resolve(this.q.insertProject({ id: project.id ?? nanoid(), ...project }))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  getProject(id: string): Promise<Project | null> {
-    try {
-      return Promise.resolve(this.q.getProject(id))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Branches ─────────────────────────────────────────────────────────────
-
-  createBranch(branch: BranchInput): Promise<Branch> {
-    try {
-      const id = branch.id ?? nanoid()
-      // Idempotent: if caller supplied an ID and it already exists, return existing
-      if (branch.id) {
-        const existing = this.q.getBranch(branch.id)
-        if (existing) return Promise.resolve(existing)
-      }
-      return Promise.resolve(this.q.insertBranch({ ...branch, id }))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  getBranch(id: string): Promise<Branch | null> {
-    try {
-      return Promise.resolve(this.q.getBranch(id))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  getBranchByGitName(projectId: string, gitBranch: string): Promise<Branch | null> {
-    try {
-      return Promise.resolve(this.q.getBranchByGitName(projectId, gitBranch))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  listBranches(projectId: string): Promise<Branch[]> {
-    try {
-      return Promise.resolve(this.q.listBranches(projectId))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  updateBranchHead(branchId: string, commitId: string): Promise<void> {
-    try {
-      this.q.updateBranchHead(branchId, commitId)
-      return Promise.resolve()
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  mergeBranch(sourceBranchId: string, targetBranchId: string, summary: string): Promise<Commit> {
-    try {
-      const result = this.db.transaction((): Commit => {
-        const sourceBranch = this.q.getBranch(sourceBranchId)
-        if (!sourceBranch) throw new Error(`Source branch not found: ${sourceBranchId}`)
-        const targetBranch = this.q.getBranch(targetBranchId)
-        if (!targetBranch) throw new Error(`Target branch not found: ${targetBranchId}`)
-
-        const mergeCommitInput: CommitInput = {
-          branchId: targetBranchId,
-          parentId: targetBranch.headCommitId,
-          agentId: 'system',
-          agentRole: 'orchestrator',
-          tool: 'contextgit',
-          workflowType: 'interactive',
-          message: `Merge ${sourceBranch.name} into ${targetBranch.name}`,
-          content: summary,
-          summary,
-          commitType: 'merge',
-        }
-
-        const mergeCommit = this.q.insertCommit(
-          nanoid(),
-          mergeCommitInput,
-          targetBranch.headCommitId ?? null,
-          sourceBranchId,
-        )
-
-        // Update target branch HEAD
-        this.q.updateBranchHead(targetBranchId, mergeCommit.id)
-
-        // Mark source branch as merged
-        this.q.markBranchMerged(sourceBranchId)
-
-        // Carry open threads from source branch to target branch
-        this.q.reassignOpenThreads(sourceBranchId, targetBranchId)
-
-        return mergeCommit
-      })()
-
-      return Promise.resolve(result)
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Commits ──────────────────────────────────────────────────────────────
-
-  createCommit(input: CommitInput): Promise<Commit> {
-    try {
-      // Idempotent: if caller supplied an ID and it already exists, return existing
-      if (input.id) {
-        const existing = this.q.getCommit(input.id)
-        if (existing) return Promise.resolve(existing)
-      }
-
-      const result = this.db.transaction((): Commit => {
-        const branch = this.q.getBranch(input.branchId)
-        if (!branch) throw new Error(`Branch not found: ${input.branchId}`)
-
-        const commitId = input.id ?? nanoid()
-        const parentId = input.parentId ?? branch.headCommitId ?? null
-
-        const commit = this.q.insertCommit(commitId, input, parentId)
-
-        // Handle thread operations
-        if (input.threads?.open?.length) {
-          for (const description of input.threads.open) {
-            this.q.insertThread(
-              nanoid(),
-              description,
-              branch.projectId,
-              input.branchId,
-              commitId,
-              input.workflowType ?? null,
-            )
-          }
-        }
-
-        if (input.threads?.close?.length) {
-          for (const { id, note } of input.threads.close) {
-            this.q.closeThread(id, commitId, note)
-          }
-        }
-
-        // Update branch HEAD
-        this.q.updateBranchHead(input.branchId, commitId)
-
-        // Update agent stats
-        this.q.incrementAgentCommits(input.agentId)
-
-        // Auto-release this agent's claims on this branch (branch-scoped)
-        this.q.releaseClaimsByAgent(input.agentId, input.branchId)
-
-        return commit
-      })()
-
-      return Promise.resolve(result)
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  getCommit(id: string): Promise<Commit | null> {
-    try {
-      return Promise.resolve(this.q.getCommit(id))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  listCommits(branchId: string, pagination: Pagination): Promise<Commit[]> {
-    try {
-      return Promise.resolve(this.q.listCommits(branchId, pagination))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Snapshots ────────────────────────────────────────────────────────────
-
-  getSessionSnapshot(projectId: string, branchId: string, options?: { agentRole?: import('@contextgit/core').AgentRole }): Promise<SessionSnapshot> {
-    try {
-      return Promise.resolve(this.q.getSessionSnapshot(projectId, branchId, options))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  getFormattedSnapshot(projectId: string, branchId: string, format: SnapshotFormat): Promise<string> {
-    try {
-      const snapshot = this.q.getSessionSnapshot(projectId, branchId)
-      return Promise.resolve(snapshotFormatter.format(snapshot, format))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Threads ──────────────────────────────────────────────────────────────
-
-  listOpenThreads(projectId: string): Promise<Thread[]> {
-    try {
-      return Promise.resolve(this.q.listOpenThreads(projectId))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  listOpenThreadsByBranch(branchId: string): Promise<Thread[]> {
-    try {
-      return Promise.resolve(this.q.listOpenThreadsByBranch(branchId))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  syncThread(thread: Thread): Promise<Thread> {
-    try {
-      return Promise.resolve(this.q.syncThread(thread))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Search ───────────────────────────────────────────────────────────────
-
-  indexEmbedding(commitId: string, vector: Float32Array): Promise<void> {
-    this.q.insertEmbedding(this.db, commitId, vector)
-    return Promise.resolve()
-  }
-
-  semanticSearch(vector: Float32Array, projectId: string, limit: number): Promise<SearchResult[]> {
-    return Promise.resolve(this.q.semanticSearch(this.db, vector, projectId, limit))
-  }
-
-  fullTextSearch(query: string, projectId: string): Promise<SearchResult[]> {
-    try {
-      return Promise.resolve(this.q.fullTextSearch(this.db, query, projectId))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Agents ───────────────────────────────────────────────────────────────
-
-  upsertAgent(agent: AgentInput): Promise<Agent> {
-    try {
-      return Promise.resolve(this.q.upsertAgent(agent))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  listAgents(projectId: string): Promise<Agent[]> {
-    try {
-      return Promise.resolve(this.q.listAgents(projectId))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Claims ───────────────────────────────────────────────────────────────
-
-  claimTask(projectId: string, branchId: string, input: ClaimInput): Promise<Claim> {
-    try {
-      return Promise.resolve(this.q.insertClaim(nanoid(), projectId, branchId, input))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  unclaimTask(claimId: string): Promise<void> {
-    try {
-      this.q.updateClaimStatus(claimId, 'released', Date.now())
-      return Promise.resolve()
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  listActiveClaims(projectId: string): Promise<Claim[]> {
-    try {
-      return Promise.resolve(this.q.listActiveClaims(projectId))
-    } catch (e) {
-      return Promise.reject(e)
-    }
-  }
-
-  // ─── Lifecycle ────────────────────────────────────────────────────────────
-
-  close(): void {
-    this.db.close()
-  }
-}
-