contextgit 0.0.2 → 0.0.3

package/packages/mcp/src/server.ts

@@ -1,377 +0,0 @@
-// server.ts — ContextGit MCP Server
-//
-// Exposes three tools to Claude and other MCP clients:
-//   context_get    — return a formatted project snapshot
-//   context_commit — persist a context commit
-//   context_search — full-text search over past commits
-//
-// Transport: stdio (launched by the MCP host, e.g. Claude Desktop / Claude Code)
-//
-// Initialization (per server process):
-//   1. Load .contextgit/config.json (search from CWD upward)
-//   2. Open LocalStore for projectId
-//   3. Detect current git branch via simple-git
-//   4. Resolve (or create) the context branch for that git branch
-//   5. Build ContextEngine, call engine.init()
-
-import os from 'os'
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { z } from 'zod'
-import { simpleGit } from 'simple-git'
-import { ContextEngine, EmbeddingService, SnapshotFormatter } from '@contextgit/core'
-import { LocalStore, RemoteStore } from '@contextgit/store'
-import { loadConfig } from './config.js'
-import { captureGitMetadata } from './git-sync.js'
-import { AutoSnapshotManager } from './auto-snapshot.js'
-import type { ContextStore } from '@contextgit/store'
-import type { ContextGitConfig } from '@contextgit/core'
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-async function detectGitBranch(): Promise<string> {
-  try {
-    const git = simpleGit(process.cwd())
-    const result = await git.revparse(['--abbrev-ref', 'HEAD'])
-    return result.trim()
-  } catch {
-    return 'main'
-  }
-}
-
-/**
- * Resolve the ContextGit branch that tracks `gitBranch`.
- * Creates one if it doesn't exist yet.
- */
-async function resolveContextBranch(
-  store: ContextStore,
-  projectId: string,
-  gitBranch: string,
-): Promise<string> {
-  const existing = await store.getBranchByGitName(projectId, gitBranch)
-  if (existing) return existing.id
-
-  const created = await store.createBranch({
-    projectId,
-    name: `Context: ${gitBranch}`,
-    gitBranch,
-  })
-  return created.id
-}
-
-// ─── Server bootstrap ─────────────────────────────────────────────────────────
-
-interface ServerContext {
-  engine: ContextEngine
-  store: ContextStore
-  projectId: string
-  branchId: string
-  config: ContextGitConfig
-}
-
-async function bootstrap(): Promise<ServerContext> {
-  const config = loadConfig()
-  const { projectId } = config
-
-  const store: ContextStore =
-    config.store && config.store !== 'local'
-      ? new RemoteStore(config.store)
-      : new LocalStore(projectId)
-
-  // Ensure the project row exists before creating branches (FK constraint)
-  const existing = await store.getProject(projectId)
-  if (!existing) {
-    await store.createProject({ id: projectId, name: config.project })
-  }
-
-  const gitBranch = await detectGitBranch()
-  const branchId = await resolveContextBranch(store, projectId, gitBranch)
-
-  const hostname = os.hostname()
-  const agentId = `${hostname}-mcp-claude-code-interactive`
-
-  const engine = new ContextEngine(
-    store,
-    agentId,
-    config.agentRole ?? 'solo',
-    'claude-code',
-    config.workflowType ?? 'interactive',
-    { embeddingService: new EmbeddingService() },
-  )
-  await engine.init(projectId, branchId)
-
-  return { engine, store, projectId, branchId, config }
-}
-
-// ─── Tool definitions ─────────────────────────────────────────────────────────
-
-export async function createServer(): Promise<McpServer> {
-  const ctx = await bootstrap()
-  const autoSnapshot = new AutoSnapshotManager(ctx.engine, {
-    interval: ctx.config.snapshotInterval ?? 10,
-  })
-
-  const server = new McpServer({
-    name: 'contextgit',
-    version: '0.0.1',
-  })
-
-  // ── context_get ─────────────────────────────────────────────────────────────
-  server.tool(
-    'context_get',
-    'Retrieve the current project snapshot. Call this at every session start to load project state.',
-    {
-      scope: z.enum(['global', 'branch']).default('global').describe(
-        "'global' returns the full project summary + branch state. 'branch' scopes to the current branch.",
-      ),
-      format: z.enum(['agents-md', 'json', 'text']).default('agents-md').describe(
-        'Output format. agents-md is optimized for agent consumption.',
-      ),
-      agent_role: z.enum(['orchestrator','dev','test','review','background','ci','solo']).optional().describe(
-        'Filter recentCommits to this agent role only. Omit to return commits from all roles.',
-      ),
-    },
-    async ({ format, agent_role }) => {
-      await autoSnapshot.onToolCall('context_get')
-      try {
-        const snapshot = await ctx.store.getSessionSnapshot(
-          ctx.projectId,
-          ctx.branchId,
-          agent_role ? { agentRole: agent_role } : undefined,
-        )
-        const text = new SnapshotFormatter().format(snapshot, format)
-        return {
-          content: [{ type: 'text', text }],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error retrieving snapshot: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  // ── context_commit ───────────────────────────────────────────────────────────
-  server.tool(
-    'context_commit',
-    'Persist a context commit recording significant work. Call this after completing meaningful tasks or milestones.',
-    {
-      message: z.string().min(1).describe('Short summary of what was accomplished (1–2 sentences).'),
-      content: z.string().min(1).describe('Detailed description of the work done, decisions made, and current state.'),
-      open_threads: z.array(z.string()).optional().describe(
-        'New open questions or blockers to track (each max 200 chars).',
-      ),
-      close_thread_ids: z.array(z.string()).optional().describe(
-        'IDs of threads to close.',
-      ),
-    },
-    async ({ message, content, open_threads, close_thread_ids }) => {
-      await autoSnapshot.onToolCall('context_commit')
-      try {
-        const threads: { open?: string[]; close?: Array<{ id: string; note: string }> } = {}
-        if (open_threads?.length) threads.open = open_threads
-        if (close_thread_ids?.length) {
-          threads.close = close_thread_ids.map(id => ({ id, note: 'Closed via context_commit' }))
-        }
-
-        const git = await captureGitMetadata(process.cwd())
-        const commit = await ctx.engine.commit({
-          message,
-          content,
-          gitCommitSha: git?.sha,
-          ...(Object.keys(threads).length > 0 ? { threads } : {}),
-        })
-
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Commit recorded.\nID: ${commit.id}\nMessage: ${commit.message}`,
-            },
-          ],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error recording commit: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  // ── context_search ───────────────────────────────────────────────────────────
-  server.tool(
-    'context_search',
-    'Search past context commits. Uses semantic + full-text search and merges results.',
-    {
-      query: z.string().min(1).describe('Search query — natural language or keywords.'),
-      limit: z.number().int().min(1).max(20).default(5).describe('Maximum results to return.'),
-    },
-    async ({ query, limit }) => {
-      await autoSnapshot.onToolCall('context_search')
-      try {
-        // Run semantic and full-text in parallel; merge by commit ID, dedup.
-        const [semantic, fts] = await Promise.all([
-          ctx.engine.semanticSearch(query, ctx.projectId, limit),
-          ctx.store.fullTextSearch(query, ctx.projectId),
-        ])
-        const seen = new Set<string>()
-        const merged = [...semantic, ...fts].filter(r => {
-          if (seen.has(r.commit.id)) return false
-          seen.add(r.commit.id)
-          return true
-        })
-        const trimmed = merged.slice(0, limit)
-
-        if (trimmed.length === 0) {
-          return {
-            content: [{ type: 'text', text: 'No results found.' }],
-          }
-        }
-
-        const formatted = trimmed
-          .map(
-            (r, i) =>
-              `[${i + 1}] ${r.commit.message}\n` +
-              `    ID: ${r.commit.id}  Score: ${r.score.toFixed(3)}\n` +
-              `    ${r.commit.content.slice(0, 200)}${r.commit.content.length > 200 ? '…' : ''}`,
-          )
-          .join('\n\n')
-
-        return {
-          content: [{ type: 'text', text: formatted }],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error searching commits: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  // ── context_branch ───────────────────────────────────────────────────────────
-  server.tool(
-    'context_branch',
-    'Create a new context branch tracking a git branch. Call this when starting work on a new git branch.',
-    {
-      git_branch: z.string().min(1).describe('The git branch name to track.'),
-      name: z.string().optional().describe('Optional display name for the context branch.'),
-    },
-    async ({ git_branch, name }) => {
-      await autoSnapshot.onToolCall('context_branch')
-      try {
-        const branch = await ctx.engine.branch(git_branch, name)
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Branch created.\nID:   ${branch.id}\nName: ${branch.name}`,
-            },
-          ],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error creating branch: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  // ── context_claim ────────────────────────────────────────────────────────────
-  server.tool(
-    'context_claim',
-    'Claim a task to prevent other agents from picking it up simultaneously. Call this before starting any significant task.',
-    {
-      task: z.string().min(1).describe('Short description of the task being claimed (e.g. "build auth module").'),
-      ttl_hours: z.number().positive().default(2).describe('Time-to-live in hours before the claim auto-expires. Default: 2.'),
-      status: z.enum(['proposed', 'active']).default('proposed').describe("'proposed' for plan-mode claims; 'active' once approved and work begins."),
-    },
-    async ({ task, ttl_hours, status }) => {
-      await autoSnapshot.onToolCall('context_claim')
-      try {
-        const claim = await ctx.store.claimTask(ctx.projectId, ctx.branchId, {
-          task,
-          agentId: `${os.hostname()}-mcp-claude-code-interactive`,
-          role: ctx.config.agentRole ?? 'solo',
-          status,
-          ttl: Math.round(ttl_hours * 3_600_000),
-        })
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Claim recorded.\nID:     ${claim.id}\nTask:   ${claim.task}\nStatus: ${claim.status}\nTTL:    ${ttl_hours}h`,
-            },
-          ],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error creating claim: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  // ── context_unclaim ──────────────────────────────────────────────────────────
-  server.tool(
-    'context_unclaim',
-    'Release a previously claimed task. Use when abandoning a task without committing.',
-    {
-      claim_id: z.string().min(1).describe('ID of the claim to release.'),
-    },
-    async ({ claim_id }) => {
-      await autoSnapshot.onToolCall('context_unclaim')
-      try {
-        await ctx.store.unclaimTask(claim_id)
-        return {
-          content: [{ type: 'text', text: `Claim released.\nID: ${claim_id}` }],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error releasing claim: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  // ── context_merge ────────────────────────────────────────────────────────────
-  server.tool(
-    'context_merge',
-    'Merge a source context branch into the current branch. Call this after merging a git branch.',
-    {
-      source_branch_id: z.string().min(1).describe('ID of the context branch to merge in.'),
-    },
-    async ({ source_branch_id }) => {
-      await autoSnapshot.onToolCall('context_merge')
-      try {
-        const commit = await ctx.engine.merge(source_branch_id)
-        return {
-          content: [
-            {
-              type: 'text',
-              text: `Merge commit recorded.\nID: ${commit.id}`,
-            },
-          ],
-        }
-      } catch (err) {
-        const message = err instanceof Error ? err.message : String(err)
-        return {
-          content: [{ type: 'text', text: `Error merging branch: ${message}` }],
-          isError: true,
-        }
-      }
-    },
-  )
-
-  return server
-}

package/packages/mcp/tsconfig.json

@@ -1,9 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "rootDir": "./src",
-    "outDir": "./dist"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}

package/packages/store/package.json

@@ -1,30 +0,0 @@
-{
-  "name": "@contextgit/store",
-  "version": "0.0.1",
-  "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
-  "exports": {
-    ".": {
-      "import": "./dist/index.js",
-      "types": "./dist/index.d.ts"
-    }
-  },
-  "scripts": {
-    "build": "tsc",
-    "test": "vitest run",
-    "typecheck": "tsc --noEmit"
-  },
-  "dependencies": {
-    "@contextgit/core": "workspace:*",
-    "better-sqlite3": "^9.4.0",
-    "nanoid": "^5.0.0",
-    "sqlite-vec": "^0.1.6"
-  },
-  "devDependencies": {
-    "@types/better-sqlite3": "^7.6.0",
-    "@types/node": "^20.0.0",
-    "typescript": "^5.4.0",
-    "vitest": "^1.6.0"
-  }
-}

package/packages/store/src/branch-merge.test.ts

@@ -1,127 +0,0 @@
-// Days 12–13 integration test: engine.branch() + engine.merge()
-//
-// Scenario: main → commit + thread → branch('feature') → 2 commits + thread
-//           → merge back to main → snapshot shows merged state + all threads.
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { ContextEngine } from '@contextgit/core'
-import { LocalStore } from './local/index.js'
-
-describe('engine.branch() + engine.merge()', () => {
-  let store: LocalStore
-  let mainEngine: ContextEngine
-  let featureEngine: ContextEngine
-
-  beforeEach(() => {
-    store         = new LocalStore(':memory:')
-    mainEngine    = new ContextEngine(store, 'agent-main', 'orchestrator', 'claude-code', 'interactive')
-    featureEngine = new ContextEngine(store, 'agent-feat', 'dev',          'claude-code', 'interactive')
-  })
-
-  afterEach(() => {
-    store.close()
-  })
-
-  it('branch → 2 commits → merge → snapshot shows merged state and all threads', async () => {
-    // 1. Setup: project + main branch
-    const project    = await store.createProject({ name: 'contextgit' })
-    const mainBranch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    await mainEngine.init(project.id, mainBranch.id)
-
-    // 2. Commit on main with an open thread
-    await mainEngine.commit({
-      message: 'Initial main commit',
-      content: 'Set up project foundation.',
-      threads: { open: ['Choose DB migration strategy'] },
-    })
-
-    // 3. Branch off main
-    const featureBranch = await mainEngine.branch('feature/auth', 'auth feature')
-
-    expect(featureBranch.gitBranch).toBe('feature/auth')
-    expect(featureBranch.name).toBe('auth feature')
-    expect(featureBranch.parentBranchId).toBe(mainBranch.id)
-    expect(featureBranch.status).toBe('active')
-
-    // feature branch should have a branch-init commit with main's summary
-    const featureCommits = await store.listCommits(featureBranch.id, { limit: 10, offset: 0 })
-    expect(featureCommits).toHaveLength(1)
-    expect(featureCommits[0].commitType).toBe('branch-init')
-    expect(featureCommits[0].summary).toBeTruthy() // carried parent summary
-
-    // 4. Two commits on feature branch (one with its own thread)
-    await featureEngine.init(project.id, featureBranch.id)
-
-    await featureEngine.commit({
-      message: 'Add auth middleware',
-      content: 'Implemented JWT middleware and route guards.',
-      threads: { open: ['Token expiry policy TBD'] },
-    })
-
-    const lastFeatureCommit = await featureEngine.commit({
-      message: 'Add login endpoint',
-      content: 'POST /auth/login with bcrypt password verification.',
-    })
-    expect(lastFeatureCommit.summary).toContain('bcrypt')
-
-    // 5. Merge feature → main
-    const mergeCommit = await mainEngine.merge(featureBranch.id)
-
-    expect(mergeCommit.commitType).toBe('merge')
-    expect(mergeCommit.branchId).toBe(mainBranch.id)
-    expect(mergeCommit.mergeSourceBranchId).toBe(featureBranch.id)
-
-    // 6. Source branch should be marked merged
-    const mergedBranch = await store.getBranch(featureBranch.id)
-    expect(mergedBranch?.status).toBe('merged')
-    expect(mergedBranch?.mergedAt).toBeTruthy()
-
-    // 7. Snapshot on main should show merged state
-    const snapshot = await mainEngine.context('global')
-
-    expect(snapshot.branchName).toBe('main')
-    // recent commits: merge commit is the newest
-    expect(snapshot.recentCommits[0].commitType).toBe('merge')
-    // open threads: both the main thread and the feature thread carried forward
-    const threadDescriptions = snapshot.openThreads.map(t => t.description)
-    expect(threadDescriptions).toContain('Choose DB migration strategy')
-    expect(threadDescriptions).toContain('Token expiry policy TBD')
-  })
-
-  it('branch-init commit carries parent HEAD summary into new branch', async () => {
-    const project    = await store.createProject({ name: 'p' })
-    const mainBranch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    await mainEngine.init(project.id, mainBranch.id)
-
-    await mainEngine.commit({ message: 'setup', content: 'foundation work done' })
-
-    const feat = await mainEngine.branch('feature/x')
-
-    // branch-init summary should match main's HEAD summary
-    const mainHead = await store.getBranch(mainBranch.id)
-    const mainHeadCommit = mainHead?.headCommitId
-      ? await store.getCommit(mainHead.headCommitId)
-      : null
-
-    const featCommits = await store.listCommits(feat.id, { limit: 1, offset: 0 })
-    expect(featCommits[0].summary).toBe(mainHeadCommit?.summary)
-  })
-
-  it('merge summary incorporates source branch content', async () => {
-    const project    = await store.createProject({ name: 'p' })
-    const mainBranch = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    await mainEngine.init(project.id, mainBranch.id)
-
-    await mainEngine.commit({ message: 'base', content: 'base content' })
-
-    const feat = await mainEngine.branch('feature/y')
-    await featureEngine.init(project.id, feat.id)
-    await featureEngine.commit({ message: 'feature work', content: 'feature specific content' })
-
-    const mergeCommit = await mainEngine.merge(feat.id)
-
-    // merge commit summary should reference feature content
-    expect(mergeCommit.summary).toBeTruthy()
-    expect(mergeCommit.content).toContain('feature specific content')
-  })
-})

package/packages/store/src/engine-integration.test.ts

@@ -1,93 +0,0 @@
-// Week 1 validation: ContextEngine + LocalStore end-to-end.
-//
-// Scenario: create project → 2 commits (one with open thread) →
-//   context('global') → snapshot shows thread + both commits.
-
-import { describe, it, expect, beforeEach, afterEach } from 'vitest'
-import { ContextEngine } from '@contextgit/core'
-import { LocalStore } from './local/index.js'
-
-describe('ContextEngine + LocalStore integration', () => {
-  let store: LocalStore
-  let engine: ContextEngine
-
-  beforeEach(() => {
-    store  = new LocalStore(':memory:')
-    engine = new ContextEngine(store, 'agent-1', 'dev', 'claude-code', 'interactive')
-  })
-
-  afterEach(() => {
-    store.close()
-  })
-
-  it('Week 1 validation: project → 2 commits → context("global") shows thread + both commits', async () => {
-    // Setup: project + branch
-    const project = await store.createProject({ name: 'contextgit', description: 'Persistent memory layer' })
-    const branch  = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    await engine.init(project.id, branch.id)
-
-    // Commit 1 — opens a thread
-    const c1 = await engine.commit({
-      message: 'Set up monorepo structure',
-      content: 'Created pnpm workspaces, tsconfig.base.json, core and store packages.',
-      threads: { open: ['Database migration strategy not decided'] },
-    })
-    expect(c1.id).toBeTruthy()
-    expect(c1.summary).toBeTruthy()
-    expect(c1.agentRole).toBe('dev')
-
-    // Commit 2 — no thread changes; summary should roll forward
-    const c2 = await engine.commit({
-      message: 'Add LocalStore implementation',
-      content: 'Implemented LocalStore with better-sqlite3, schema, migrations, queries.',
-    })
-    expect(c2.id).toBeTruthy()
-    // Rolling summary must include the new content
-    expect(c2.summary).toContain('LocalStore')
-
-    // context('global') → SessionSnapshot
-    const snapshot = await engine.context('global')
-
-    expect(snapshot.branchName).toBe('main')
-    expect(snapshot.recentCommits).toHaveLength(2)
-    expect(snapshot.recentCommits[0].message).toBe('Add LocalStore implementation')
-    expect(snapshot.recentCommits[1].message).toBe('Set up monorepo structure')
-
-    // Open thread from commit 1 must survive commit 2
-    expect(snapshot.openThreads).toHaveLength(1)
-    expect(snapshot.openThreads[0].description).toBe('Database migration strategy not decided')
-  })
-
-  it('summarizer rolls content into previous summary', async () => {
-    const project = await store.createProject({ name: 'p' })
-    const branch  = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    await engine.init(project.id, branch.id)
-
-    const c1 = await engine.commit({ message: 'first', content: 'alpha content' })
-    const c2 = await engine.commit({ message: 'second', content: 'beta content' })
-
-    // c2 summary must contain both pieces (budget large enough for test data)
-    expect(c2.summary).toContain('alpha content')
-    expect(c2.summary).toContain('beta content')
-    // c1 summary should be just the first content
-    expect(c1.summary).toBe('alpha content')
-  })
-
-  it('context("branch") returns the same snapshot as context("global")', async () => {
-    const project = await store.createProject({ name: 'p' })
-    const branch  = await store.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    await engine.init(project.id, branch.id)
-    await engine.commit({ message: 'm', content: 'c' })
-
-    const global = await engine.context('global')
-    const branchCtx = await engine.context('branch')
-    expect(branchCtx.branchName).toBe(global.branchName)
-    expect(branchCtx.recentCommits).toHaveLength(global.recentCommits.length)
-  })
-
-  it('throws if context() called before init()', async () => {
-    const uninitEngine = new ContextEngine(store, 'a', 'solo', 'cli', 'interactive')
-    await expect(uninitEngine.context('global')).rejects.toThrow('not initialized')
-  })
-})

package/packages/store/src/index.ts

@@ -1,3 +0,0 @@
-export type { ContextStore } from './interface.js'
-export { LocalStore } from './local/index.js'
-export { RemoteStore } from './remote/index.js'