contextgit 0.0.1 → 0.0.2

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

@@ -0,0 +1,99 @@
+// 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

@@ -0,0 +1,141 @@
+// 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

@@ -0,0 +1,65 @@
+// 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

@@ -0,0 +1,103 @@
+// 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

@@ -0,0 +1,36 @@
+// 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

@@ -0,0 +1,145 @@
+// 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}`)
+  }
+}