contextgit 0.0.2 → 0.0.4

package/packages/cli/src/commands/doctor.ts

@@ -1,99 +0,0 @@
-// doctor — diagnose the ContextGit installation and report issues.
-
-import os from 'os'
-import { join, resolve } from 'path'
-import { existsSync, readFileSync } from 'fs'
-import { Command } from '@oclif/core'
-import { LocalStore } from '@contextgit/store'
-import { findConfigPath } from '../config.js'
-
-const SENTINEL = '# contextgit'
-
-export default class DoctorCmd extends Command {
-  static description = 'Check ContextGit setup and diagnose issues'
-
-  async run(): Promise<void> {
-    this.log('ContextGit Doctor\n')
-
-    let passed = 0
-    let failed = 0
-
-    const check = (label: string, ok: boolean, hint?: string) => {
-      const icon = ok ? '✓' : '✗'
-      this.log(`  [${icon}] ${label}`)
-      if (!ok && hint) this.log(`        → ${hint}`)
-      ok ? passed++ : failed++
-    }
-
-    // ── 1. Config file ────────────────────────────────────────────────────────
-    let configPath: string | null = null
-    let config: Record<string, unknown> | null = null
-    try {
-      configPath = findConfigPath(process.cwd())
-      config = JSON.parse(readFileSync(configPath, 'utf-8')) as Record<string, unknown>
-      check('Config file found and valid JSON', true)
-    } catch {
-      check('Config file found and valid JSON', false, 'Run: contextgit init')
-    }
-
-    // ── 2. DB reachable ───────────────────────────────────────────────────────
-    if (config?.projectId) {
-      try {
-        const store = new LocalStore(config.projectId as string)
-        await store.getProject(config.projectId as string)
-        check('Local DB reachable', true)
-      } catch {
-        check('Local DB reachable', false, 'DB file may be corrupted — try: contextgit init')
-      }
-    } else {
-      check('Local DB reachable', false, 'No config to check DB against')
-    }
-
-    // ── 3. Git hooks installed ────────────────────────────────────────────────
-    const gitHooksDir = resolve(process.cwd(), '.git', 'hooks')
-    const postCommitPath = join(gitHooksDir, 'post-commit')
-    const hooksInstalled = existsSync(postCommitPath) &&
-      readFileSync(postCommitPath, 'utf-8').includes(SENTINEL)
-    check(
-      'Git hooks installed',
-      hooksInstalled,
-      'Run: contextgit init --hooks',
-    )
-
-    // ── 4. API key configured (only relevant if remote is set) ────────────────
-    const remote = config?.remote as string | undefined
-    if (remote) {
-      const serverCfgPath = join(os.homedir(), '.contextgit', 'server.json')
-      let hasKey = false
-      try {
-        const cfg = JSON.parse(readFileSync(serverCfgPath, 'utf-8')) as Record<string, unknown>
-        hasKey = typeof cfg['keyHash'] === 'string' && cfg['keyHash'].length > 0
-      } catch { /* not configured */ }
-      check(
-        `API key configured (remote: ${remote})`,
-        hasKey,
-        'Run: contextgit keygen --save',
-      )
-    } else {
-      check('API key (no remote configured — skipped)', true)
-    }
-
-    // ── 5. MCP registered in ~/.claude.json ───────────────────────────────────
-    const claudeJsonPath = join(os.homedir(), '.claude.json')
-    let mcpRegistered = false
-    try {
-      const raw = readFileSync(claudeJsonPath, 'utf-8')
-      mcpRegistered = raw.includes('contextgit')
-    } catch { /* file missing */ }
-    check(
-      'MCP server registered in ~/.claude.json',
-      mcpRegistered,
-      'Add contextgit to mcpServers in ~/.claude.json',
-    )
-
-    // ── Summary ───────────────────────────────────────────────────────────────
-    this.log('')
-    this.log(`${passed} passed, ${failed} failed`)
-    if (failed > 0) process.exitCode = 1
-  }
-}

package/packages/cli/src/commands/init.ts

@@ -1,141 +0,0 @@
-// init — create .contextgit/config.json + project + branch in LocalStore.
-
-import { Command, Flags } from '@oclif/core'
-import { writeFileSync, mkdirSync, existsSync, readFileSync } from 'fs'
-import { join, basename } from 'path'
-import { nanoid } from 'nanoid'
-import { simpleGit } from 'simple-git'
-import { LocalStore } from '@contextgit/store'
-import type { ContextGitConfig } from '@contextgit/core'
-import { installGitHooks } from '../git-hooks.js'
-
-const SYSTEM_PROMPT_FRAGMENT = `\
-You have access to ContextGit memory tools. At the start of every session, call
-context_get with scope=global to load project state. After completing significant
-work, call context_commit with a message describing what was done and any open
-threads. Use context_branch before exploring risky changes.
-`
-
-export default class Init extends Command {
-  static description = 'Initialize ContextGit in this project'
-
-  static flags = {
-    name: Flags.string({
-      char: 'n',
-      description: 'Project name (defaults to current directory name)',
-      required: false,
-    }),
-    hooks: Flags.boolean({
-      description: 'Install git hooks to auto-capture context on every git commit',
-      default: false,
-    }),
-  }
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(Init)
-    const cwd = process.cwd()
-    const configDir  = join(cwd, '.contextgit')
-    const configPath = join(configDir, 'config.json')
-    const promptPath = join(configDir, 'system-prompt.md')
-
-    // ── Self-heal: config exists but DB may be empty ───────────────────────────
-    if (existsSync(configPath)) {
-      let existing: ContextGitConfig
-      try {
-        existing = JSON.parse(readFileSync(configPath, 'utf8')) as ContextGitConfig
-      } catch {
-        this.error('Found .contextgit/config.json but could not parse it. Delete it and re-run init.')
-      }
-
-      const store = new LocalStore(existing.projectId)
-      const gitBranch = await detectGitBranch(cwd)
-      const branch = await store.getBranchByGitName(existing.projectId, gitBranch)
-
-      if (branch) {
-        this.log('ContextGit already initialized. Config found at .contextgit/config.json')
-        return
-      }
-
-      // DB missing or empty — recreate project + branch
-      this.log('Config found but DB is empty — recreating project and branch in DB.')
-      await store.createProject({ id: existing.projectId, name: existing.project })
-      await store.createBranch({
-        projectId: existing.projectId,
-        name: `Context: ${gitBranch}`,
-        gitBranch,
-      })
-      writeSystemPrompt(promptPath)
-      this.log(`Recreated project "${existing.project}" (${existing.projectId}) for branch: ${gitBranch}`)
-      this.log(`System prompt: .contextgit/system-prompt.md`)
-      this.log(SYSTEM_PROMPT_FRAGMENT)
-      if (flags.hooks) {
-        installGitHooks(cwd)
-        this.log('Git hooks installed (.git/hooks/post-commit, post-checkout, post-merge)')
-      }
-      return
-    }
-
-    // ── Fresh init ─────────────────────────────────────────────────────────────
-    const projectName = flags.name ?? basename(cwd)
-    const projectId = nanoid()
-
-    // Open store (creates DB + runs migrations).
-    const store = new LocalStore(projectId)
-    await store.createProject({ id: projectId, name: projectName })
-
-    const gitBranch = await detectGitBranch(cwd)
-
-    await store.createBranch({
-      projectId,
-      name: `Context: ${gitBranch}`,
-      gitBranch,
-    })
-
-    // Write config
-    mkdirSync(configDir, { recursive: true })
-    const config: ContextGitConfig = {
-      project: projectName,
-      projectId,
-      store: 'local',
-      agentRole: 'solo',
-      workflowType: 'interactive',
-      autoSnapshot: false,
-      snapshotInterval: 10,
-      embeddingModel: 'local',
-    }
-    writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n')
-    writeSystemPrompt(promptPath)
-
-    this.log(`Initialized ContextGit for project: ${projectName}`)
-    this.log(`Project ID:  ${projectId}`)
-    this.log(`Branch:      ${gitBranch}`)
-    this.log(`Config:      .contextgit/config.json`)
-    this.log(`DB:          ~/.contextgit/projects/${projectId}.db`)
-    this.log(``)
-    if (flags.hooks) {
-      installGitHooks(cwd)
-      this.log(`Git hooks installed (.git/hooks/post-commit, post-checkout, post-merge)`)
-    } else {
-      this.log(`Tip: run "contextgit init --hooks" to auto-capture context on every git commit`)
-    }
-    this.log(``)
-    this.log(`Add the following to your MCP system prompt (.contextgit/system-prompt.md):`)
-    this.log(``)
-    this.log(SYSTEM_PROMPT_FRAGMENT)
-  }
-}
-
-// ─── Helpers ──────────────────────────────────────────────────────────────────
-
-async function detectGitBranch(cwd: string): Promise<string> {
-  try {
-    const git = simpleGit(cwd)
-    return (await git.revparse(['--abbrev-ref', 'HEAD'])).trim()
-  } catch {
-    return 'main'
-  }
-}
-
-function writeSystemPrompt(promptPath: string): void {
-  writeFileSync(promptPath, SYSTEM_PROMPT_FRAGMENT)
-}

package/packages/cli/src/commands/keygen.ts

@@ -1,65 +0,0 @@
-// keygen — generate an API key and optionally save its hash to ~/.contextgit/server.json.
-//
-// The plaintext key is shown once and never written to disk. Only the SHA-256
-// hash is persisted so the server can verify Bearer tokens without storing secrets.
-
-import os from 'os'
-import { join } from 'path'
-import { createHash } from 'crypto'
-import { mkdirSync, readFileSync, writeFileSync } from 'fs'
-import { Command, Flags } from '@oclif/core'
-import { nanoid } from 'nanoid'
-
-const CONTEXTGIT_DIR = join(os.homedir(), '.contextgit')
-const SERVER_CONFIG_PATH = join(CONTEXTGIT_DIR, 'server.json')
-
-function sha256hex(input: string): string {
-  return createHash('sha256').update(input, 'utf8').digest('hex')
-}
-
-function readServerConfig(): Record<string, unknown> {
-  try {
-    return JSON.parse(readFileSync(SERVER_CONFIG_PATH, 'utf-8')) as Record<string, unknown>
-  } catch {
-    return {}
-  }
-}
-
-function saveKeyHash(hash: string): void {
-  mkdirSync(CONTEXTGIT_DIR, { recursive: true })
-  const cfg = { ...readServerConfig(), keyHash: hash }
-  writeFileSync(SERVER_CONFIG_PATH, JSON.stringify(cfg, null, 2) + '\n', { mode: 0o600 })
-}
-
-export default class KeygenCmd extends Command {
-  static description = 'Generate an API key for securing the ContextGit API server'
-
-  static flags = {
-    save: Flags.boolean({
-      description: 'Save the key hash to ~/.contextgit/server.json (key shown once, never stored)',
-      default: false,
-    }),
-    length: Flags.integer({
-      description: 'Key length (default 32)',
-      default: 32,
-    }),
-  }
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(KeygenCmd)
-
-    const key = nanoid(flags.length)
-
-    this.log(`API Key: ${key}`)
-    this.log(`(Copy this now — it will not be stored anywhere in plaintext)`)
-
-    if (flags.save) {
-      saveKeyHash(sha256hex(key))
-      this.log(`\nKey hash saved to ~/.contextgit/server.json`)
-      this.log(`Set this key in the Authorization header when calling the API:`)
-      this.log(`  Authorization: Bearer ${key}`)
-    } else {
-      this.log(`\nTo activate this key, re-run with --save`)
-    }
-  }
-}

package/packages/cli/src/commands/log.ts

@@ -1,103 +0,0 @@
-// log — list context commits with formatting.
-
-import { Command, Flags } from '@oclif/core'
-import { simpleGit } from 'simple-git'
-import { LocalStore } from '@contextgit/store'
-import { loadConfig } from '../config.js'
-
-export default class LogCmd extends Command {
-  static description = 'List context commits for the current branch'
-
-  static flags = {
-    limit: Flags.integer({
-      char: 'n',
-      description: 'Max commits to show',
-      default: 20,
-    }),
-    all: Flags.boolean({
-      char: 'a',
-      description: 'Show commits across all branches',
-      default: false,
-    }),
-    branch: Flags.string({
-      char: 'b',
-      description: 'Show commits for a specific git branch name',
-    }),
-    verbose: Flags.boolean({
-      char: 'v',
-      description: 'Show full commit content',
-      default: false,
-    }),
-  }
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(LogCmd)
-    const config = loadConfig()
-    const store = new LocalStore(config.projectId)
-    const cwd = process.cwd()
-
-    let gitBranch = 'main'
-    try {
-      gitBranch = (await simpleGit(cwd).revparse(['--abbrev-ref', 'HEAD'])).trim()
-    } catch {
-      // fallback
-    }
-
-    if (flags.all) {
-      const branches = await store.listBranches(config.projectId)
-      if (branches.length === 0) {
-        this.log('No branches found. Run `contextgit init` first.')
-        return
-      }
-
-      for (const branch of branches) {
-        const commits = await store.listCommits(branch.id, { limit: flags.limit, offset: 0 })
-        if (commits.length === 0) continue
-
-        this.log(`\n── ${branch.name} (${branch.gitBranch}) ──`)
-        this.printCommits(commits, flags.verbose)
-      }
-    } else {
-      const targetGitBranch = flags.branch ?? gitBranch
-      const branch = await store.getBranchByGitName(config.projectId, targetGitBranch)
-      if (!branch) {
-        this.error(
-          `No context branch for git branch '${targetGitBranch}'. Run 'contextgit init' first.`,
-        )
-      }
-
-      const commits = await store.listCommits(branch.id, { limit: flags.limit, offset: 0 })
-      if (commits.length === 0) {
-        this.log(`No commits on branch '${branch.name}'.`)
-        return
-      }
-
-      this.log(`Branch: ${branch.name}  [${branch.gitBranch}]`)
-      this.log(`Showing ${commits.length} commit(s)\n`)
-      this.printCommits(commits, flags.verbose)
-    }
-  }
-
-  private printCommits(
-    commits: import('@contextgit/core').Commit[],
-    verbose: boolean,
-  ): void {
-    for (const c of commits) {
-      const ts = new Date(c.createdAt).toLocaleString()
-      const sha = c.gitCommitSha ? `  git:${c.gitCommitSha.slice(0, 7)}` : ''
-      const agent = c.agentId ? `  [${c.agentId}]` : ''
-      this.log(`commit ${c.id}`)
-      this.log(`Date:   ${ts}${sha}${agent}`)
-      this.log(``)
-      this.log(`    ${c.message}`)
-      if (verbose && c.content && c.content !== c.message) {
-        this.log(``)
-        const lines = c.content.split('\n')
-        for (const line of lines) {
-          this.log(`    ${line}`)
-        }
-      }
-      this.log(``)
-    }
-  }
-}

package/packages/cli/src/commands/merge.ts

@@ -1,36 +0,0 @@
-// merge — merge a context branch into the current branch.
-
-import { Command, Args, Flags } from '@oclif/core'
-import { bootstrap } from '../bootstrap.js'
-
-export default class MergeCmd extends Command {
-  static description = 'Merge a context branch into the current branch'
-
-  static args = {
-    sourceBranchId: Args.string({
-      description: 'ID of the source branch to merge from',
-      required: true,
-    }),
-  }
-
-  static flags = {
-    summary: Flags.string({
-      char: 's',
-      description: 'Summary of what was merged (defaults to a generic message)',
-      required: false,
-    }),
-  }
-
-  async run(): Promise<void> {
-    const { args, flags } = await this.parse(MergeCmd)
-    const ctx = await bootstrap()
-
-    const summary = flags.summary ?? `Merged branch ${args.sourceBranchId} into current branch`
-
-    const mergeCommit = await ctx.store.mergeBranch(args.sourceBranchId, ctx.branchId, summary)
-
-    this.log(`Branch merged.`)
-    this.log(`Merge commit ID: ${mergeCommit.id}`)
-    this.log(`Summary: ${mergeCommit.summary}`)
-  }
-}

package/packages/cli/src/commands/pull.ts

@@ -1,145 +0,0 @@
-// pull — pull context commits from a remote ContextGit API server into local store.
-//
-// Requires `remote` in .contextgit/config.json.
-// Algorithm:
-//   1. Ensure project exists locally (by ID — already initialized)
-//   2. For each remote branch: ensure branch exists locally
-//   3. For each branch: collect remote commits not present locally, write them
-
-import { Command, Flags } from '@oclif/core'
-import { LocalStore, RemoteStore } from '@contextgit/store'
-import type { Pagination } from '@contextgit/core'
-import { loadConfig } from '../config.js'
-
-const PAGE = 100
-
-async function allCommits(
-  store: LocalStore | RemoteStore,
-  branchId: string,
-): Promise<import('@contextgit/core').Commit[]> {
-  const acc: import('@contextgit/core').Commit[] = []
-  let offset = 0
-  const pg: Pagination = { limit: PAGE, offset }
-  while (true) {
-    pg.offset = offset
-    const page = await store.listCommits(branchId, pg)
-    acc.push(...page)
-    if (page.length < PAGE) break
-    offset += PAGE
-  }
-  return acc
-}
-
-export default class PullCmd extends Command {
-  static description = 'Pull context commits from a remote ContextGit API'
-
-  static flags = {
-    remote: Flags.string({
-      char: 'r',
-      description: 'Remote API URL (overrides config.remote)',
-      required: false,
-    }),
-    'dry-run': Flags.boolean({
-      description: 'Show what would be pulled without writing locally',
-      default: false,
-    }),
-  }
-
-  async run(): Promise<void> {
-    const { flags } = await this.parse(PullCmd)
-    const config = loadConfig()
-
-    const remoteUrl = flags.remote ?? config.remote
-    if (!remoteUrl) {
-      this.error(
-        'No remote configured. Add "remote": "<url>" to .contextgit/config.json or pass --remote.',
-      )
-    }
-
-    const local = new LocalStore(config.projectId)
-    const remote = new RemoteStore(remoteUrl)
-    const dryRun = flags['dry-run']
-
-    // Verify project exists on remote
-    const remoteProject = await remote.getProject(config.projectId).catch(() => null)
-    if (!remoteProject) {
-      this.error(`Project ${config.projectId} not found on remote ${remoteUrl}. Push first.`)
-    }
-
-    // List all remote branches
-    const remoteBranches = await remote.listBranches(config.projectId)
-    let totalPulled = 0
-
-    for (const branch of remoteBranches) {
-      // Ensure branch exists locally
-      const localBranch = await local.getBranch(branch.id).catch(() => null)
-      if (!localBranch) {
-        if (!dryRun) {
-          await local.createBranch({
-            id: branch.id,
-            projectId: branch.projectId,
-            name: branch.name,
-            gitBranch: branch.gitBranch,
-            parentBranchId: branch.parentBranchId,
-          })
-        }
-        this.log(`[branch] ${dryRun ? 'would create' : 'created'}: ${branch.name}`)
-      }
-
-      // Collect local commit IDs for this branch
-      const localCommits = await allCommits(local, branch.id)
-      const localCommitIds = new Set(localCommits.map(c => c.id))
-
-      // Pull missing commits from remote
-      const remoteCommits = await allCommits(remote, branch.id)
-      const missing = remoteCommits.filter(c => !localCommitIds.has(c.id))
-
-      if (missing.length === 0) {
-        this.log(`[branch] ${branch.name}: up to date (${remoteCommits.length} commits)`)
-        continue
-      }
-
-      this.log(`[branch] ${branch.name}: pulling ${missing.length} commit(s)…`)
-
-      for (const commit of missing) {
-        if (!dryRun) {
-          await local.createCommit({
-            id: commit.id,
-            branchId: commit.branchId,
-            parentId: commit.parentId,
-            agentId: commit.agentId,
-            agentRole: commit.agentRole,
-            tool: commit.tool,
-            workflowType: commit.workflowType,
-            loopIteration: commit.loopIteration,
-            ciRunId: commit.ciRunId,
-            pipelineName: commit.pipelineName,
-            message: commit.message,
-            content: commit.content,
-            summary: commit.summary,
-            commitType: commit.commitType,
-            gitCommitSha: commit.gitCommitSha,
-          })
-        }
-        totalPulled++
-      }
-    }
-
-    // Thread sync: pull open threads that are missing locally
-    const remoteThreads = await remote.listOpenThreads(config.projectId)
-    const localThreads = await local.listOpenThreads(config.projectId)
-    const localThreadIds = new Set(localThreads.map(t => t.id))
-    const missingThreads = remoteThreads.filter(t => !localThreadIds.has(t.id))
-    if (missingThreads.length > 0) {
-      this.log(`\n[threads] pulling ${missingThreads.length} open thread(s)…`)
-      for (const thread of missingThreads) {
-        if (!dryRun) {
-          await local.syncThread(thread)
-        }
-        this.log(`  ${dryRun ? 'would pull' : 'pulled'}: ${thread.description}`)
-      }
-    }
-
-    this.log(`\nDone. ${dryRun ? '(dry run) ' : ''}${totalPulled} commit(s), ${missingThreads.length} thread(s) pulled from ${remoteUrl}`)
-  }
-}