contextgit 0.0.2 → 0.0.4

package/packages/api/src/middleware/auth.ts

@@ -1,41 +0,0 @@
-// auth.ts — Bearer token authentication middleware
-//
-// Accepts a pre-computed SHA-256 hex digest of the API key (keyHashHex).
-// Every request must include an `Authorization: Bearer <key>` header whose
-// SHA-256 hash matches the stored digest.
-// When keyHashHex is absent the server runs in dev mode (all requests pass).
-
-import { createHash, timingSafeEqual } from 'crypto'
-import type { Request, Response, NextFunction } from 'express'
-
-function sha256(input: string): Buffer {
-  return createHash('sha256').update(input, 'utf8').digest()
-}
-
-export function createAuthMiddleware(keyHashHex: string | undefined) {
-  if (!keyHashHex) {
-    // Dev mode — no key configured, pass all requests
-    return (_req: Request, _res: Response, next: NextFunction): void => next()
-  }
-
-  const expectedHash = Buffer.from(keyHashHex, 'hex')
-
-  return (req: Request, res: Response, next: NextFunction): void => {
-    const authHeader = req.headers['authorization']
-
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
-      res.status(401).json({ error: 'Authorization required' })
-      return
-    }
-
-    const token = authHeader.slice(7)
-    const tokenHash = sha256(token)
-
-    if (tokenHash.length !== expectedHash.length || !timingSafeEqual(tokenHash, expectedHash)) {
-      res.status(401).json({ error: 'Invalid API key' })
-      return
-    }
-
-    next()
-  }
-}

package/packages/api/src/remote-store.test.ts

@@ -1,301 +0,0 @@
-// Integration test: RemoteStore ↔ LocalStore
-//
-// Scenario: spin up an Express server with the store router backed by an
-// in-memory LocalStore, then run CRUD through a RemoteStore client and verify
-// the results match what LocalStore returns directly.
-
-import { describe, it, expect, beforeAll, afterAll } from 'vitest'
-import express from 'express'
-import http from 'http'
-import type { AddressInfo } from 'net'
-import { LocalStore, RemoteStore } from '@contextgit/store'
-import { createStoreRouter } from './store-router.js'
-
-describe('RemoteStore ↔ LocalStore integration', () => {
-  let server: http.Server
-  let localStore: LocalStore
-  let remote: RemoteStore
-
-  beforeAll(async () => {
-    localStore = new LocalStore(':memory:')
-
-    const app = express()
-    app.use(express.json())
-    app.use('/v1/store', createStoreRouter(localStore))
-
-    server = http.createServer(app)
-    const port = await new Promise<number>(resolve =>
-      server.listen(0, () => resolve((server.address() as AddressInfo).port)),
-    )
-
-    remote = new RemoteStore(`http://localhost:${port}`)
-  })
-
-  afterAll(() => {
-    return new Promise<void>(resolve => {
-      server.close(() => {
-        localStore.close()
-        resolve()
-      })
-    })
-  })
-
-  it('creates and retrieves a project via RemoteStore', async () => {
-    const project = await remote.createProject({ name: 'remote-test', description: 'HTTP project' })
-    expect(project.id).toBeTruthy()
-    expect(project.name).toBe('remote-test')
-    expect(project.createdAt).toBeInstanceOf(Date)
-
-    // Directly confirm it's in LocalStore
-    const local = await localStore.getProject(project.id)
-    expect(local?.name).toBe('remote-test')
-  })
-
-  it('creates a branch and retrieves by git name', async () => {
-    const project = await remote.createProject({ name: 'branch-proj' })
-    const branch = await remote.createBranch({
-      projectId: project.id,
-      name: 'main',
-      gitBranch: 'main',
-    })
-    expect(branch.id).toBeTruthy()
-    expect(branch.gitBranch).toBe('main')
-    expect(branch.createdAt).toBeInstanceOf(Date)
-
-    const byGit = await remote.getBranchByGitName(project.id, 'main')
-    expect(byGit?.id).toBe(branch.id)
-
-    const notFound = await remote.getBranchByGitName(project.id, 'nonexistent')
-    expect(notFound).toBeNull()
-  })
-
-  it('creates a commit and retrieves it', async () => {
-    const project = await remote.createProject({ name: 'commit-proj' })
-    const branch = await remote.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    await remote.upsertAgent({
-      id: 'agent-remote',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-    })
-
-    const commit = await remote.createCommit({
-      branchId: branch.id,
-      agentId: 'agent-remote',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'Remote commit',
-      content: 'Content via HTTP',
-      summary: 'Summary',
-      commitType: 'manual',
-    })
-    expect(commit.id).toBeTruthy()
-    expect(commit.message).toBe('Remote commit')
-    expect(commit.createdAt).toBeInstanceOf(Date)
-
-    const fetched = await remote.getCommit(commit.id)
-    expect(fetched?.message).toBe('Remote commit')
-  })
-
-  it('getFormattedSnapshot via RemoteStore matches LocalStore output', async () => {
-    const project = await remote.createProject({ name: 'snap-proj' })
-    const branch = await remote.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    await remote.upsertAgent({
-      id: 'snap-agent',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-    })
-
-    await remote.createCommit({
-      branchId: branch.id,
-      agentId: 'snap-agent',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'First commit',
-      content: 'Setting things up',
-      summary: 'Project scaffolded',
-      commitType: 'manual',
-    })
-
-    const remoteSnapshot = await remote.getFormattedSnapshot(project.id, branch.id, 'text')
-    const localSnapshot = await localStore.getFormattedSnapshot(project.id, branch.id, 'text')
-
-    // Both should contain the expected sections
-    expect(remoteSnapshot).toContain('=== PROJECT STATE ===')
-    expect(remoteSnapshot).toContain('Project scaffolded')
-
-    // RemoteStore and LocalStore return the same formatted text
-    expect(remoteSnapshot).toBe(localSnapshot)
-  })
-
-  it('open threads round-trip via RemoteStore', async () => {
-    const project = await remote.createProject({ name: 'thread-proj' })
-    const branch = await remote.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    await remote.upsertAgent({
-      id: 'thread-agent',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-    })
-
-    await remote.createCommit({
-      branchId: branch.id,
-      agentId: 'thread-agent',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'Open a thread',
-      content: 'Some work',
-      summary: 'Work in progress',
-      commitType: 'manual',
-      threads: { open: ['Which auth approach to use?'] },
-    })
-
-    const threads = await remote.listOpenThreads(project.id)
-    expect(threads).toHaveLength(1)
-    expect(threads[0].description).toBe('Which auth approach to use?')
-    expect(threads[0].createdAt).toBeInstanceOf(Date)
-  })
-
-  it('fullTextSearch returns results via RemoteStore', async () => {
-    const project = await remote.createProject({ name: 'search-proj' })
-    const branch = await remote.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    await remote.upsertAgent({
-      id: 'search-agent',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-    })
-
-    await remote.createCommit({
-      branchId: branch.id,
-      agentId: 'search-agent',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'Add authentication',
-      content: 'Implemented JWT RS256 for authentication',
-      summary: 'JWT auth done',
-      commitType: 'manual',
-    })
-
-    const results = await remote.fullTextSearch('JWT', project.id)
-    expect(results.length).toBeGreaterThan(0)
-    expect(results[0].commit.createdAt).toBeInstanceOf(Date)
-    expect(results[0].matchType).toBe('fulltext')
-  })
-
-  it('mergeBranch carries threads via RemoteStore', async () => {
-    const project = await remote.createProject({ name: 'merge-proj' })
-    const main = await remote.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-    const feat = await remote.createBranch({
-      projectId: project.id,
-      name: 'feat',
-      gitBranch: 'feat',
-      parentBranchId: main.id,
-    })
-
-    await remote.upsertAgent({
-      id: 'merge-agent',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-    })
-
-    await remote.createCommit({
-      branchId: main.id,
-      agentId: 'merge-agent',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'main init',
-      content: 'c',
-      summary: 's',
-      commitType: 'branch-init',
-    })
-
-    await remote.createCommit({
-      branchId: feat.id,
-      agentId: 'merge-agent',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'feat work',
-      content: 'c',
-      summary: 's',
-      commitType: 'manual',
-      threads: { open: ['Thread from feat'] },
-    })
-
-    const mergeCommit = await remote.mergeBranch(feat.id, main.id, 'Merged feat into main')
-    expect(mergeCommit.commitType).toBe('merge')
-    expect(mergeCommit.createdAt).toBeInstanceOf(Date)
-
-    // Source branch is merged
-    const updatedFeat = await remote.getBranch(feat.id)
-    expect(updatedFeat?.status).toBe('merged')
-
-    // Thread carried to main branch
-    const mainThreads = await remote.listOpenThreadsByBranch(main.id)
-    expect(mainThreads).toHaveLength(1)
-    expect(mainThreads[0].description).toBe('Thread from feat')
-  })
-
-  it('syncThread is idempotent and round-trips via RemoteStore', async () => {
-    const project = await remote.createProject({ name: 'sync-thread-proj' })
-    const branch = await remote.createBranch({ projectId: project.id, name: 'main', gitBranch: 'main' })
-
-    await remote.upsertAgent({
-      id: 'sync-agent',
-      projectId: project.id,
-      role: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-    })
-
-    // Create a commit so we have a valid openedInCommit reference
-    const commit = await remote.createCommit({
-      branchId: branch.id,
-      agentId: 'sync-agent',
-      agentRole: 'dev',
-      tool: 'test',
-      workflowType: 'interactive',
-      message: 'Seed commit',
-      content: 'c',
-      summary: 's',
-      commitType: 'manual',
-    })
-
-    // Construct a Thread as if it came from another store (e.g. during push/pull)
-    const thread = await remote.syncThread({
-      id: 'sync-thread-id-1',
-      projectId: project.id,
-      branchId: branch.id,
-      description: 'Synced open question',
-      status: 'open',
-      openedInCommit: commit.id,
-      createdAt: new Date(),
-    })
-    expect(thread.id).toBe('sync-thread-id-1')
-    expect(thread.description).toBe('Synced open question')
-
-    // Idempotent: calling again should not throw
-    await expect(remote.syncThread(thread)).resolves.toBeDefined()
-
-    // Thread visible via listOpenThreads
-    const open = await remote.listOpenThreads(project.id)
-    expect(open.some(t => t.id === 'sync-thread-id-1')).toBe(true)
-  })
-})

package/packages/api/src/router.ts

@@ -1,121 +0,0 @@
-// router.ts — Express router for ContextGit REST API
-//
-// Routes:
-//   POST /commits  — engine.commit() — persist a context commit
-//   GET  /snapshot — store.getFormattedSnapshot() — formatted project snapshot
-//   GET  /search   — store.fullTextSearch() — full-text search over commits
-
-import { Router, Request, Response } from 'express'
-import type { ApiContext } from './bootstrap.js'
-import type { SnapshotFormat } from '@contextgit/core'
-
-export function createRouter(ctx: ApiContext): Router {
-  const router = Router()
-
-  // ── POST /commits ──────────────────────────────────────────────────────────
-  // Body: { message, content, open_threads?, close_thread_ids? }
-  router.post('/commits', async (req: Request, res: Response) => {
-    try {
-      const { message, content, open_threads, close_thread_ids } = req.body as {
-        message?: unknown
-        content?: unknown
-        open_threads?: unknown
-        close_thread_ids?: unknown
-      }
-
-      if (typeof message !== 'string' || message.trim() === '') {
-        res.status(400).json({ error: "'message' is required and must be a non-empty string" })
-        return
-      }
-      if (typeof content !== 'string' || content.trim() === '') {
-        res.status(400).json({ error: "'content' is required and must be a non-empty string" })
-        return
-      }
-
-      const threads: { open?: string[]; close?: Array<{ id: string; note: string }> } = {}
-
-      if (Array.isArray(open_threads) && open_threads.length > 0) {
-        threads.open = open_threads.map(String)
-      }
-      if (Array.isArray(close_thread_ids) && close_thread_ids.length > 0) {
-        threads.close = close_thread_ids.map((id: unknown) => ({
-          id: String(id),
-          note: 'Closed via API',
-        }))
-      }
-
-      const commit = await ctx.engine.commit({
-        message,
-        content,
-        ...(Object.keys(threads).length > 0 ? { threads } : {}),
-      })
-
-      res.status(201).json({ id: commit.id, message: commit.message, createdAt: commit.createdAt })
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err)
-      res.status(500).json({ error: message })
-    }
-  })
-
-  // ── GET /snapshot ──────────────────────────────────────────────────────────
-  // Query: ?format=agents-md|json|text  (default: agents-md)
-  router.get('/snapshot', async (req: Request, res: Response) => {
-    try {
-      const format = (req.query['format'] ?? 'agents-md') as SnapshotFormat
-      const validFormats: SnapshotFormat[] = ['agents-md', 'json', 'text']
-      if (!validFormats.includes(format)) {
-        res.status(400).json({ error: `'format' must be one of: ${validFormats.join(', ')}` })
-        return
-      }
-
-      const snapshot = await ctx.store.getFormattedSnapshot(ctx.projectId, ctx.branchId, format)
-
-      if (format === 'json') {
-        res.setHeader('Content-Type', 'application/json')
-        res.send(snapshot)
-      } else {
-        res.setHeader('Content-Type', 'text/plain; charset=utf-8')
-        res.send(snapshot)
-      }
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err)
-      res.status(500).json({ error: message })
-    }
-  })
-
-  // ── GET /search ────────────────────────────────────────────────────────────
-  // Query: ?q=<query>&limit=<n>  (limit default: 5, max: 20)
-  router.get('/search', async (req: Request, res: Response) => {
-    try {
-      const q = req.query['q']
-      if (typeof q !== 'string' || q.trim() === '') {
-        res.status(400).json({ error: "'q' query parameter is required" })
-        return
-      }
-
-      const limitRaw = parseInt(String(req.query['limit'] ?? '5'), 10)
-      const limit = Number.isNaN(limitRaw) ? 5 : Math.min(Math.max(limitRaw, 1), 20)
-
-      const results = await ctx.store.fullTextSearch(q, ctx.projectId)
-      const trimmed = results.slice(0, limit)
-
-      res.json({
-        query: q,
-        total: trimmed.length,
-        results: trimmed.map(r => ({
-          id: r.commit.id,
-          message: r.commit.message,
-          content: r.commit.content,
-          score: r.score,
-          matchType: r.matchType,
-          createdAt: r.commit.createdAt,
-        })),
-      })
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err)
-      res.status(500).json({ error: message })
-    }
-  })
-
-  return router
-}

package/packages/api/src/server-config.ts

@@ -1,34 +0,0 @@
-// server-config.ts — global server configuration at ~/.contextgit/server.json
-//
-// Stores the SHA-256 hash of the API key so the plaintext key never rests on disk.
-// The server reads the hash on startup; keygen --save writes it.
-
-import os from 'os'
-import { join } from 'path'
-import { mkdirSync, readFileSync, writeFileSync } from 'fs'
-import { createHash } from 'crypto'
-
-const CONTEXTGIT_DIR = join(os.homedir(), '.contextgit')
-const SERVER_CONFIG_PATH = join(CONTEXTGIT_DIR, 'server.json')
-
-export interface ServerConfig {
-  keyHash?: string   // SHA-256 hex digest of the API key
-}
-
-export function sha256hex(input: string): string {
-  return createHash('sha256').update(input, 'utf8').digest('hex')
-}
-
-export function readServerConfig(): ServerConfig {
-  try {
-    const raw = readFileSync(SERVER_CONFIG_PATH, 'utf-8')
-    return JSON.parse(raw) as ServerConfig
-  } catch {
-    return {}
-  }
-}
-
-export function writeServerConfig(config: ServerConfig): void {
-  mkdirSync(CONTEXTGIT_DIR, { recursive: true })
-  writeFileSync(SERVER_CONFIG_PATH, JSON.stringify(config, null, 2) + '\n', { mode: 0o600 })
-}

package/packages/api/src/server.ts

@@ -1,38 +0,0 @@
-// server.ts — ContextGit REST API server
-//
-// Creates and configures the Express app. Separated from index.ts so tests
-// can import createApp() without binding to a port.
-
-import express from 'express'
-import type { Express } from 'express'
-import { bootstrap } from './bootstrap.js'
-import { createRouter } from './router.js'
-import { createStoreRouter } from './store-router.js'
-import { createAuthMiddleware } from './middleware/auth.js'
-import { readServerConfig, sha256hex } from './server-config.js'
-
-export async function createApp(): Promise<Express> {
-  const ctx = await bootstrap()
-
-  // Resolve key hash: prefer ~/.contextgit/server.json, fall back to env var
-  const serverCfg = readServerConfig()
-  let keyHashHex = serverCfg.keyHash
-  if (!keyHashHex) {
-    const envKey = process.env['CONTEXTGIT_API_KEY']
-    if (envKey) keyHashHex = sha256hex(envKey)
-  }
-
-  const app = express()
-  app.use(express.json())
-  app.use(createAuthMiddleware(keyHashHex))
-
-  app.use('/v1/store', createStoreRouter(ctx.store))
-  app.use('/', createRouter(ctx))
-
-  // 404 catch-all
-  app.use((_req, res) => {
-    res.status(404).json({ error: 'Not found' })
-  })
-
-  return app
-}