contextgit 0.0.2 → 0.0.4

package/packages/core/src/embeddings.test.ts

@@ -1,58 +0,0 @@
-import { describe, it, expect, vi } from 'vitest'
-import { EmbeddingService } from './embeddings.js'
-
-// Fake pipeline that returns a predictable 384-dim vector
-function makeFakePipeline() {
-  return async (_text: string, _opts: unknown) => ({
-    data: new Float32Array(384).fill(0.5),
-  })
-}
-
-function makeBrokenPipeline() {
-  return Promise.reject(new Error('model load failed'))
-}
-
-describe('EmbeddingService', () => {
-  it('returns a Float32Array of length 384 on success', async () => {
-    const svc = new EmbeddingService({
-      pipelineFactory: async () => makeFakePipeline(),
-    })
-    const vec = await svc.embed('hello world')
-    expect(vec).toBeInstanceOf(Float32Array)
-    expect(vec!.length).toBe(384)
-  })
-
-  it('returns null when pipeline load fails', async () => {
-    const svc = new EmbeddingService({
-      pipelineFactory: async () => { throw new Error('load error') },
-    })
-    const vec = await svc.embed('hello')
-    expect(vec).toBeNull()
-  })
-
-  it('returns null when pipeline call throws', async () => {
-    const svc = new EmbeddingService({
-      pipelineFactory: async () => {
-        return async () => { throw new Error('inference error') }
-      },
-    })
-    const vec = await svc.embed('hello')
-    expect(vec).toBeNull()
-  })
-
-  it('never throws — always returns null on any error', async () => {
-    const svc = new EmbeddingService({
-      pipelineFactory: () => makeBrokenPipeline() as never,
-    })
-    await expect(svc.embed('anything')).resolves.toBeNull()
-  })
-
-  it('loads the pipeline only once across multiple embeds', async () => {
-    const factory = vi.fn(async () => makeFakePipeline())
-    const svc = new EmbeddingService({ pipelineFactory: factory })
-    await svc.embed('a')
-    await svc.embed('b')
-    await svc.embed('c')
-    expect(factory).toHaveBeenCalledTimes(1)
-  })
-})

package/packages/core/src/embeddings.ts

@@ -1,75 +0,0 @@
-// EmbeddingService — generates 384-dim sentence embeddings using
-// @xenova/transformers (all-MiniLM-L6-v2, runs fully local, no API key).
-//
-// Usage:
-//   const svc = new EmbeddingService()
-//   const vector = await svc.embed('some text')   // Float32Array | null
-//
-// Load failure is silently swallowed — callers receive null and should fall
-// back to full-text search.  Never let embedding errors propagate outward.
-
-type PipelineFn = (text: string, options: { pooling: string; normalize: boolean }) => Promise<{ data: Float32Array }>
-
-export interface EmbeddingServiceOptions {
-  /** Override the pipeline factory — for tests. */
-  pipelineFactory?: (task: string, model: string) => Promise<PipelineFn>
-}
-
-export class EmbeddingService {
-  private pipeline: PipelineFn | null = null
-  private loadPromise: Promise<void> | null = null
-  private readonly pipelineFactory: (task: string, model: string) => Promise<PipelineFn>
-
-  static readonly MODEL = 'Xenova/all-MiniLM-L6-v2'
-  static readonly DIMS  = 384
-
-  constructor(options: EmbeddingServiceOptions = {}) {
-    this.pipelineFactory = options.pipelineFactory ?? EmbeddingService.defaultPipelineFactory
-  }
-
-  /**
-   * Generate a 384-dim embedding for `text`.
-   * Returns null if the model is unavailable or any error occurs.
-   */
-  async embed(text: string): Promise<Float32Array | null> {
-    try {
-      await this.ensureLoaded()
-      if (!this.pipeline) return null
-      const result = await this.pipeline(text, { pooling: 'mean', normalize: true })
-      return result.data
-    } catch {
-      return null
-    }
-  }
-
-  /** True once the model has been loaded at least once (even if it failed). */
-  get isReady(): boolean {
-    return this.loadPromise !== null
-  }
-
-  private async ensureLoaded(): Promise<void> {
-    if (this.pipeline) return
-    if (!this.loadPromise) {
-      this.loadPromise = this.load()
-    }
-    await this.loadPromise
-  }
-
-  private async load(): Promise<void> {
-    try {
-      this.pipeline = await this.pipelineFactory('feature-extraction', EmbeddingService.MODEL)
-    } catch {
-      this.pipeline = null
-    }
-  }
-
-  private static async defaultPipelineFactory(_task: string, model: string): Promise<PipelineFn> {
-    // Dynamic import so the heavy @xenova/transformers bundle is only loaded
-    // when embeddings are actually needed.
-    const { pipeline } = await import('@xenova/transformers')
-    // Cast task to any to avoid strict PipelineType enum mismatch — we always
-    // pass 'feature-extraction' which is valid at runtime.
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    return pipeline('feature-extraction' as any, model) as unknown as PipelineFn
-  }
-}

package/packages/core/src/engine.ts

@@ -1,274 +0,0 @@
-// ContextEngine — pure business logic layer, no I/O.
-// All persistence is delegated to the injected ContextStore.
-//
-// Usage:
-//   const engine = new ContextEngine(store, 'agent-1', 'dev', 'claude-code', 'interactive')
-//   await engine.init(projectId, branchId)
-//   await engine.commit({ message: '...', content: '...' })
-//   const snapshot = await engine.context('global')
-
-import type {
-  AgentRole,
-  Branch,
-  Commit,
-  CommitType,
-  ContextScope,
-  SearchResult,
-  SessionSnapshot,
-  WorkflowType,
-} from './types.js'
-import { RollingSummarizer } from './summarizer.js'
-import { EmbeddingService } from './embeddings.js'
-
-// ─── Store subset the engine requires ─────────────────────────────────────────
-
-interface EngineBranchInput {
-  projectId: string
-  name: string
-  gitBranch: string
-  parentBranchId?: string
-}
-
-export interface EngineStore {
-  getBranch(id: string): Promise<{ headCommitId?: string; gitBranch?: string; name?: string } | null>
-  getCommit(id: string): Promise<{ summary: string } | null>
-  createBranch(input: EngineBranchInput): Promise<Branch>
-  createCommit(input: EngineCommitStoreInput): Promise<Commit>
-  mergeBranch(sourceBranchId: string, targetBranchId: string, summary: string): Promise<Commit>
-  getSessionSnapshot(projectId: string, branchId: string): Promise<SessionSnapshot>
-  upsertAgent(agent: EngineAgentInput): Promise<unknown>
-  indexEmbedding(commitId: string, vector: Float32Array): Promise<void>
-  semanticSearch(vector: Float32Array, projectId: string, limit: number): Promise<SearchResult[]>
-}
-
-interface EngineCommitStoreInput {
-  branchId: string
-  agentId: string
-  agentRole: AgentRole
-  tool: string
-  workflowType: WorkflowType
-  message: string
-  content: string
-  summary: string
-  commitType: CommitType
-  gitCommitSha?: string
-  ciRunId?: string
-  pipelineName?: string
-  threads?: {
-    open?: string[]
-    close?: Array<{ id: string; note: string }>
-  }
-}
-
-interface EngineAgentInput {
-  id: string
-  projectId: string
-  role: AgentRole
-  tool: string
-  workflowType: WorkflowType
-}
-
-// ─── Public API ───────────────────────────────────────────────────────────────
-
-export interface EngineCommitInput {
-  message: string
-  content: string
-  commitType?: CommitType
-  gitCommitSha?: string
-  ciRunId?: string
-  pipelineName?: string
-  threads?: {
-    open?: string[]
-    close?: Array<{ id: string; note: string }>
-  }
-}
-
-export interface EngineOptions {
-  summarizer?: RollingSummarizer
-  embeddingService?: EmbeddingService
-}
-
-export class ContextEngine {
-  private projectId = ''
-  private branchId  = ''
-  private readonly summarizer: RollingSummarizer
-  private readonly embeddings: EmbeddingService | null
-
-  constructor(
-    private readonly store: EngineStore,
-    private readonly agentId: string,
-    private readonly agentRole: AgentRole,
-    private readonly tool: string,
-    private readonly workflowType: WorkflowType,
-    options: EngineOptions = {},
-  ) {
-    this.summarizer = options.summarizer ?? new RollingSummarizer()
-    this.embeddings = options.embeddingService ?? null
-  }
-
-  /**
-   * Bind the engine to a project + branch and register this agent.
-   * Must be called before commit() or context().
-   */
-  async init(projectId: string, branchId: string): Promise<void> {
-    this.projectId = projectId
-    this.branchId  = branchId
-    await this.store.upsertAgent({
-      id: this.agentId,
-      projectId,
-      role: this.agentRole,
-      tool: this.tool,
-      workflowType: this.workflowType,
-    })
-  }
-
-  /**
-   * Persist a context commit.  Summary is generated automatically via the
-   * RollingSummarizer (Week 1: string truncation; Week 2: Claude Haiku).
-   */
-  async commit(input: EngineCommitInput): Promise<Commit> {
-    this.assertInitialized()
-
-    // Fetch previous summary from branch HEAD (if any)
-    let previousSummary = ''
-    const branch = await this.store.getBranch(this.branchId)
-    if (branch?.headCommitId) {
-      const head = await this.store.getCommit(branch.headCommitId)
-      previousSummary = head?.summary ?? ''
-    }
-
-    const summary = await this.summarizer.summarize(input.content, previousSummary, 'branch')
-
-    const commit = await this.store.createCommit({
-      branchId:     this.branchId,
-      agentId:      this.agentId,
-      agentRole:    this.agentRole,
-      tool:         this.tool,
-      workflowType: this.workflowType,
-      message:      input.message,
-      content:      input.content,
-      summary,
-      commitType:   input.commitType ?? 'manual',
-      gitCommitSha: input.gitCommitSha,
-      ciRunId:      input.ciRunId,
-      pipelineName: input.pipelineName,
-      threads:      input.threads,
-    })
-
-    // Generate and index embedding asynchronously — never block the commit.
-    if (this.embeddings) {
-      const text = `${input.message}\n${input.content}`
-      this.embeddings.embed(text).then(vector => {
-        if (vector) return this.store.indexEmbedding(commit.id, vector)
-      }).catch(() => { /* swallow — indexing is best-effort */ })
-    }
-
-    return commit
-  }
-
-  /**
-   * Create a new branch from the current branch.
-   * Writes a `branch-init` commit on the new branch carrying the parent HEAD
-   * summary forward so the branch starts with full context.
-   */
-  async branch(gitBranch: string, name?: string): Promise<Branch> {
-    this.assertInitialized()
-
-    // Carry parent HEAD summary into the new branch
-    const parentBranch = await this.store.getBranch(this.branchId)
-    let parentSummary = ''
-    if (parentBranch?.headCommitId) {
-      const head = await this.store.getCommit(parentBranch.headCommitId)
-      parentSummary = head?.summary ?? ''
-    }
-
-    const newBranch = await this.store.createBranch({
-      projectId: this.projectId,
-      name: name ?? gitBranch,
-      gitBranch,
-      parentBranchId: this.branchId,
-    })
-
-    // branch-init commit: carries parent summary, no rolling summarization needed
-    await this.store.createCommit({
-      branchId:     newBranch.id,
-      agentId:      this.agentId,
-      agentRole:    this.agentRole,
-      tool:         this.tool,
-      workflowType: this.workflowType,
-      message:      `Branch ${gitBranch} created from ${parentBranch?.gitBranch ?? this.branchId}`,
-      content:      parentSummary,
-      summary:      parentSummary,
-      commitType:   'branch-init',
-    })
-
-    return newBranch
-  }
-
-  /**
-   * Merge a source branch into the current branch.
-   * Generates a rolling summary for the merge commit, carries open threads
-   * from source to target, and marks the source branch as merged.
-   */
-  async merge(sourceBranchId: string): Promise<Commit> {
-    this.assertInitialized()
-
-    // Source HEAD summary
-    const sourceBranch = await this.store.getBranch(sourceBranchId)
-    let sourceSummary = ''
-    if (sourceBranch?.headCommitId) {
-      const head = await this.store.getCommit(sourceBranch.headCommitId)
-      sourceSummary = head?.summary ?? ''
-    }
-
-    // Target (current branch) HEAD summary as the rolling base
-    const targetBranch = await this.store.getBranch(this.branchId)
-    let targetSummary = ''
-    if (targetBranch?.headCommitId) {
-      const head = await this.store.getCommit(targetBranch.headCommitId)
-      targetSummary = head?.summary ?? ''
-    }
-
-    const mergeContent = `Merged ${sourceBranch?.name ?? sourceBranchId}: ${sourceSummary}`
-    const mergeSummary = await this.summarizer.summarize(mergeContent, targetSummary, 'branch')
-
-    return this.store.mergeBranch(sourceBranchId, this.branchId, mergeSummary)
-  }
-
-  /**
-   * Retrieve a SessionSnapshot for the current project+branch.
-   *
-   * scope='global'  → full project snapshot (project summary + branch state)
-   * scope='branch'  → same as global for now (branch-scoped view, Week 2)
-   * Other scopes    → throws until implemented in later weeks
-   */
-  async context(scope: ContextScope): Promise<SessionSnapshot> {
-    this.assertInitialized()
-
-    if (scope === 'global' || scope === 'branch') {
-      return this.store.getSessionSnapshot(this.projectId, this.branchId)
-    }
-
-    throw new Error(`context scope '${scope}' is not yet implemented`)
-  }
-
-  /**
-   * Semantic search over commits in the current project.
-   * Requires an EmbeddingService to have been passed at construction time;
-   * returns an empty array if embeddings are unavailable.
-   */
-  async semanticSearch(query: string, projectId: string, limit = 5): Promise<SearchResult[]> {
-    if (!this.embeddings) return []
-    const vector = await this.embeddings.embed(query)
-    if (!vector) return []
-    return this.store.semanticSearch(vector, projectId, limit)
-  }
-
-  private assertInitialized(): void {
-    if (!this.projectId || !this.branchId) {
-      throw new Error(
-        'ContextEngine not initialized — call engine.init(projectId, branchId) first.',
-      )
-    }
-  }
-}

package/packages/core/src/index.ts

@@ -1,6 +0,0 @@
-export * from './types.js'
-export * from './summarizer.js'
-export * from './snapshot.js'
-export * from './threads.js'
-export * from './engine.js'
-export * from './embeddings.js'

package/packages/core/src/snapshot.ts

@@ -1,82 +0,0 @@
-// SnapshotFormatter — converts a SessionSnapshot to one of the 3 output formats.
-// Moved from store/local/index.ts (inline) to core so all consumers share the same output.
-
-import type { SessionSnapshot, SnapshotFormat } from './types.js'
-
-export class SnapshotFormatter {
-  format(snapshot: SessionSnapshot, fmt: SnapshotFormat): string {
-    const { projectSummary, branchName, branchSummary, recentCommits, openThreads, activeClaims } = snapshot
-
-    if (fmt === 'json') {
-      return JSON.stringify(snapshot, null, 2)
-    }
-
-    if (fmt === 'agents-md') {
-      const commits = recentCommits
-        .map(
-          (c) =>
-            `- [${c.createdAt.toISOString()}] "${c.message}" by ${c.agentRole} via ${c.tool} (${c.workflowType})`,
-        )
-        .join('\n')
-      const threads = openThreads
-        .map(
-          (t) =>
-            `- [ ] ${t.description}  (opened ${t.createdAt.toLocaleDateString()}, ${t.workflowType ?? 'interactive'})`,
-        )
-        .join('\n')
-      const claims = activeClaims
-        .map((cl) => `- [${cl.status}] ${cl.task}  by ${cl.agentId} (${cl.role})`)
-        .join('\n')
-      return [
-        `## Project State`,
-        projectSummary || '(no summary yet)',
-        ``,
-        `## Current Branch: ${branchName}`,
-        branchSummary || '(no branch summary yet)',
-        ``,
-        `## Recent Activity`,
-        commits || '(no commits yet)',
-        ``,
-        `## Open Threads`,
-        threads || '(none)',
-        ``,
-        `## Active Claims`,
-        claims || '(none)',
-      ].join('\n')
-    }
-
-    // text (default)
-    const commits = recentCommits
-      .map(
-        (c) =>
-          `[${c.createdAt.toISOString()}] "${c.message}"  by ${c.agentRole} via ${c.tool} (${c.workflowType})`,
-      )
-      .join('\n')
-    const threads = openThreads
-      .map(
-        (t) =>
-          `[ ] ${t.description}  (opened ${t.createdAt.toLocaleDateString()}, ${t.workflowType ?? 'interactive'})`,
-      )
-      .join('\n')
-    const claims = activeClaims
-      .map((cl) => `[${cl.status}] ${cl.task}  by ${cl.agentId} (${cl.role})`)
-      .join('\n')
-
-    return [
-      `=== PROJECT STATE ===`,
-      projectSummary || '(no summary yet)',
-      ``,
-      `=== CURRENT BRANCH: ${branchName} ===`,
-      branchSummary || '(no branch summary yet)',
-      ``,
-      `=== LAST 3 COMMITS ===`,
-      commits || '(none)',
-      ``,
-      `=== OPEN THREADS ===`,
-      threads || '(none)',
-      ``,
-      `=== ACTIVE CLAIMS ===`,
-      claims || '(none)',
-    ].join('\n')
-  }
-}

package/packages/core/src/summarizer.test.ts

@@ -1,120 +0,0 @@
-// Week 2 summarizer tests.
-// All API calls are mocked — no network required.
-
-import { describe, it, expect, vi, beforeEach } from 'vitest'
-import Anthropic from '@anthropic-ai/sdk'
-import { RollingSummarizer } from './summarizer.js'
-
-// ─── Helpers ─────────────────────────────────────────────────────────────────
-
-function makeClient(responseText: string): Anthropic {
-  const client = new Anthropic({ apiKey: 'test-key' })
-  vi.spyOn(client.messages, 'create').mockResolvedValue({
-    id: 'msg_test',
-    type: 'message',
-    role: 'assistant',
-    content: [{ type: 'text', text: responseText }],
-    model: 'claude-haiku-4-5',
-    stop_reason: 'end_turn',
-    stop_sequence: null,
-    usage: { input_tokens: 10, output_tokens: 20 },
-  } as Awaited<ReturnType<typeof client.messages.create>>)
-  return client
-}
-
-function makeFailingClient(): Anthropic {
-  const client = new Anthropic({ apiKey: 'test-key' })
-  vi.spyOn(client.messages, 'create').mockRejectedValue(
-    new Error('Simulated API failure'),
-  )
-  return client
-}
-
-// ─── Tests ───────────────────────────────────────────────────────────────────
-
-describe('RollingSummarizer', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks()
-  })
-
-  it('returns Claude summary when API succeeds', async () => {
-    const claudeReply = 'Concise summary from Claude Haiku.'
-    const summarizer = new RollingSummarizer({ client: makeClient(claudeReply) })
-
-    const result = await summarizer.summarize('some content', '', 'branch')
-
-    expect(result).toBe(claudeReply)
-  })
-
-  it('passes previous summary and new content to Claude', async () => {
-    const client = makeClient('merged summary')
-    const summarizer = new RollingSummarizer({ client })
-
-    await summarizer.summarize('new work', 'old summary', 'branch')
-
-    const callArg = (client.messages.create as ReturnType<typeof vi.fn>).mock
-      .calls[0][0] as Anthropic.MessageCreateParamsNonStreaming
-    const userContent = callArg.messages[0].content as string
-    expect(userContent).toContain('old summary')
-    expect(userContent).toContain('new work')
-  })
-
-  it('falls back to string truncation when API fails', async () => {
-    const summarizer = new RollingSummarizer({ client: makeFailingClient() })
-
-    const result = await summarizer.summarize('beta', 'alpha', 'branch')
-
-    // Fallback: concatenate and keep; both fit in 2000 chars
-    expect(result).toContain('alpha')
-    expect(result).toContain('beta')
-  })
-
-  it('never throws when API fails', async () => {
-    const summarizer = new RollingSummarizer({ client: makeFailingClient() })
-
-    await expect(
-      summarizer.summarize('content', '', 'branch'),
-    ).resolves.toBeDefined()
-  })
-
-  it('falls back to string truncation when no client is injected and ANTHROPIC_API_KEY is absent', async () => {
-    const savedKey = process.env['ANTHROPIC_API_KEY']
-    delete process.env['ANTHROPIC_API_KEY']
-
-    try {
-      const summarizer = new RollingSummarizer()
-      const result = await summarizer.summarize('beta content', 'alpha content', 'branch')
-      expect(result).toContain('alpha content')
-      expect(result).toContain('beta content')
-    } finally {
-      if (savedKey !== undefined) process.env['ANTHROPIC_API_KEY'] = savedKey
-    }
-  })
-
-  it('truncates from the start (keeps newest) when fallback overflows budget', async () => {
-    const savedKey = process.env['ANTHROPIC_API_KEY']
-    delete process.env['ANTHROPIC_API_KEY']
-
-    try {
-      const summarizer = new RollingSummarizer({ maxBranchChars: 20 })
-      const result = await summarizer.summarize('NEWEST', 'A'.repeat(30), 'branch')
-      // Budget is 20 chars; tail of the combined string should end with NEWEST
-      expect(result).toHaveLength(20)
-      expect(result.endsWith('NEWEST')).toBe(true)
-    } finally {
-      if (savedKey !== undefined) process.env['ANTHROPIC_API_KEY'] = savedKey
-    }
-  })
-
-  it('respects maxChars for Claude response (truncates to budget)', async () => {
-    const longReply = 'X'.repeat(5000)
-    const summarizer = new RollingSummarizer({
-      client: makeClient(longReply),
-      maxBranchChars: 100,
-    })
-
-    const result = await summarizer.summarize('content', '', 'branch')
-
-    expect(result).toHaveLength(100)
-  })
-})