can-i-merge 0.1.0 → 0.2.0

package/README.md

@@ -1,4 +1,284 @@
-# PA
+<div align="center">
 
-## license
-CC BY-NC-SA 4.0
+# can-i-merge
+
+### Before you merge, ask one question.
+
+> **can-i-merge?**
+
+AI-powered Git review pipeline with intelligent context building.
+
+[![License: MIT](https://img.shields.io/badge/license-MIT-blue.svg)](#license)
+[![TypeScript](https://img.shields.io/badge/TypeScript-5.x-blue)](#)
+[![Node.js](https://img.shields.io/badge/Node.js-20+-green)](#)
+
+</div>
+
+---
+
+## Why?
+
+Most AI code review tools simply send your changed files to an LLM.
+
+**can-i-merge** does something different.
+
+Instead of asking:
+
+> "Which AI should I use?"
+
+It asks:
+
+> **"What is the best context I can give the AI?"**
+
+The AI is replaceable.
+
+The **Context Engine** is the real product.
+
+---
+
+## Features
+
+- Git Diff analysis
+- Intelligent Context Builder
+- Context Budget Engine
+- Dependency-aware context collection
+- Multiple AI providers
+    - Claude
+    - OpenAI
+    - NVIDIA
+    - Gemini
+    - Ollama
+    - OpenRouter
+- Provider abstraction
+- GitHub Action (Planned)
+- VSCode Extension (Planned)
+- MCP Server (Planned)
+- Review Memory (Planned)
+
+---
+
+## Philosophy
+
+Good AI reviews don't come from better models.
+
+They come from better context.
+
+```
+Git Diff
+      │
+      ▼
+Context Engine
+      │
+      ▼
+Claude / GPT / Gemini / NVIDIA
+      │
+      ▼
+Normalized Review
+```
+
+---
+
+## Installation
+
+```bash
+npm install -g can-i-merge
+```
+
+---
+
+## Usage
+
+Review current changes
+
+```bash
+can-i-merge
+```
+
+Review latest commit
+
+```bash
+can-i-merge --commit HEAD
+```
+
+Deep review
+
+```bash
+can-i-merge --level deep
+```
+
+Choose AI provider
+
+```bash
+can-i-merge --provider claude
+```
+
+Security review
+
+```bash
+can-i-merge --type security
+```
+
+JSON output
+
+```bash
+can-i-merge --json
+```
+
+---
+
+## Example
+
+```text
+$ can-i-merge
+
+Analyzing Git Diff...
+Building Context...
+Reviewing with Claude...
+
+────────────────────────────
+
+Overall Score
+
+92 / 100
+
+Critical
+0
+
+High
+1
+
+Medium
+2
+
+Low
+1
+
+────────────────────────────
+
+❌ Merge Status
+
+NOT READY
+
+────────────────────────────
+
+High
+
+src/auth/login.ts:48
+
+JWT validation should happen after authorization.
+
+Recommendation
+
+Move authorization check before JWT validation.
+```
+
+---
+
+# Architecture
+
+```
+                Git Repository
+                       │
+                       ▼
+                Git Analyzer
+                       │
+                       ▼
+               Context Builder
+       ┌──────────────────────────┐
+       │ Dependency Resolver      │
+       │ Context Score Engine     │
+       │ Context Budget Engine    │
+       │ Prompt Builder           │
+       │ Review Memory            │
+       └──────────────────────────┘
+                       │
+                       ▼
+                Provider Layer
+       ┌──────────────────────────┐
+       │ Claude                   │
+       │ OpenAI                   │
+       │ NVIDIA                   │
+       │ Gemini                   │
+       │ Ollama                   │
+       └──────────────────────────┘
+                       │
+                       ▼
+                  Normalizer
+                       │
+                       ▼
+                  ReviewResult
+```
+
+---
+
+# Why another AI review tool?
+
+Most tools focus on the AI.
+
+We focus on the context.
+
+Instead of sending an entire repository to an LLM,
+can-i-merge builds the smallest, most relevant context possible.
+
+That means:
+
+- Lower cost
+- Faster reviews
+- Better answers
+- Model independence
+
+---
+
+# Roadmap
+
+## v0.1
+
+- CLI
+- Git Diff Analyzer
+- Context Builder
+- Claude Provider
+- Terminal Reporter
+
+---
+
+## v0.2
+
+- Context Budget Engine
+- Context Score Engine
+- OpenAI Provider
+- NVIDIA Provider
+- Ollama Provider
+
+---
+
+## v0.3
+
+- Review Memory
+- Incremental Review
+- GitHub Action
+- VSCode Extension
+
+---
+
+## v1.0
+
+- Multi AI Consensus
+- MCP Server
+- Dashboard
+- Auto Fix
+- Team Review
+
+---
+
+# Contributing
+
+Contributions are welcome.
+
+If you have ideas for improving the Context Engine,
+please open an issue or submit a pull request.
+
+---
+
+# License
+
+MIT License

package/dist/cli/index.js

@@ -0,0 +1,152 @@
+/**
+ * CLI composition root.
+ *
+ * This is the only place in the project that wires a concrete provider
+ * (ClaudeProvider) into the provider-agnostic Core pipeline. Adding a new
+ * provider later means registering it here - runReview() in core never
+ * changes.
+ */
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { clearProviderConfig, loadProviderConfig, saveProviderConfig } from "../config/index.js";
+import { NoChangesError, runReview } from "../core/index.js";
+import { isGitRepository } from "../git/index.js";
+import { ProviderRegistry } from "../provider/index.js";
+import { ClaudeProvider } from "../provider-anthropic/index.js";
+import { NvidiaProvider } from "../provider-nvidia/index.js";
+import { OllamaProvider } from "../provider-ollama/index.js";
+import { OpenAIProvider } from "../provider-openai/index.js";
+import { isMergeReady, reportConsole, reportJson } from "../reporter/index.js";
+import { colors } from "../shared/colors.js";
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const pkg = JSON.parse(readFileSync(path.join(__dirname, "..", "..", "package.json"), "utf8"));
+const REVIEW_LEVELS = ["fast", "normal", "deep"];
+const REVIEW_TYPES = [
+    "general",
+    "security",
+    "performance",
+    "architecture",
+    "style",
+];
+const STAGE_MESSAGES = {
+    analyzing: "Analyzing Git Diff...",
+    context: "Building Context...",
+    reviewing: "Reviewing...",
+};
+const PROVIDER_ENV_VARS = {
+    claude: { apiKey: "ANTHROPIC_API_KEY", model: "ANTHROPIC_MODEL" },
+    openai: { apiKey: "OPENAI_API_KEY", model: "OPENAI_MODEL" },
+    nvidia: { apiKey: "NVIDIA_API_KEY", model: "NVIDIA_MODEL" },
+    ollama: { apiKey: "OLLAMA_API_KEY", model: "OLLAMA_MODEL" },
+};
+function isReviewLevel(value) {
+    return REVIEW_LEVELS.includes(value);
+}
+function isReviewType(value) {
+    return REVIEW_TYPES.includes(value);
+}
+function buildProviderRegistry() {
+    const registry = new ProviderRegistry();
+    registry.register("claude", (config) => new ClaudeProvider(config));
+    registry.register("openai", (config) => new OpenAIProvider(config));
+    registry.register("nvidia", (config) => new NvidiaProvider(config));
+    registry.register("ollama", (config) => new OllamaProvider(config));
+    return registry;
+}
+export async function main(argv = process.argv) {
+    const program = new Command();
+    program
+        .name("can-i-merge")
+        .description("AI-powered Git Review Pipeline with Intelligent Context Building")
+        .version(pkg.version)
+        .option("--commit <ref>", "review a specific commit instead of the staged index")
+        .option("--provider <name>", "AI provider to use: claude, openai, nvidia, or ollama", "claude")
+        .option("--api-key <key>", "API key for the selected provider (saved encrypted for future runs)")
+        .option("--model <model>", "model name for the selected provider (saved for future runs)")
+        .option("--forget-credentials", "remove stored credentials for the selected provider and exit", false)
+        .option("--level <level>", "review level: fast, normal, or deep", "normal")
+        .option("--type <type>", "review focus: general, security, performance, architecture, or style", "general")
+        .option("--json", "output the review result as JSON", false)
+        .option("--fix", "automatically apply suggested fixes (not yet supported)", false);
+    program.parse(argv);
+    const opts = program.opts();
+    if (opts.forgetCredentials) {
+        clearProviderConfig(opts.provider);
+        console.log(colors.green(`Removed stored credentials for provider "${opts.provider}".`));
+        return;
+    }
+    if (opts.fix) {
+        console.error(colors.yellow("--fix is not supported yet (see TOBE.md roadmap, Phase 4)."));
+        process.exitCode = 2;
+        return;
+    }
+    if (!isReviewLevel(opts.level)) {
+        console.error(colors.red(`Invalid --level "${opts.level}". Expected one of: ${REVIEW_LEVELS.join(", ")}.`));
+        process.exitCode = 2;
+        return;
+    }
+    if (!isReviewType(opts.type)) {
+        console.error(colors.red(`Invalid --type "${opts.type}". Expected one of: ${REVIEW_TYPES.join(", ")}.`));
+        process.exitCode = 2;
+        return;
+    }
+    const cwd = process.cwd();
+    if (!(await isGitRepository(cwd))) {
+        console.error(colors.red(`Not a git repository: ${cwd}`));
+        process.exitCode = 2;
+        return;
+    }
+    if (opts.apiKey !== undefined || opts.model !== undefined) {
+        saveProviderConfig(opts.provider, { apiKey: opts.apiKey, model: opts.model });
+        if (!opts.json) {
+            console.log(colors.dim(`Saved ${opts.provider} credentials to ~/.can-i-merge (encrypted).`));
+        }
+    }
+    const stored = loadProviderConfig(opts.provider);
+    const envVars = PROVIDER_ENV_VARS[opts.provider];
+    const apiKey = opts.apiKey ?? (envVars && process.env[envVars.apiKey]) ?? stored.apiKey;
+    const model = opts.model ?? (envVars && process.env[envVars.model]) ?? stored.model;
+    const registry = buildProviderRegistry();
+    let provider;
+    try {
+        provider = registry.create(opts.provider, { apiKey, model });
+    }
+    catch (err) {
+        console.error(colors.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 2;
+        return;
+    }
+    if (!opts.json) {
+        console.log(colors.bold(`can-i-merge v${pkg.version}`));
+    }
+    try {
+        const result = await runReview({
+            cwd,
+            commit: opts.commit,
+            level: opts.level,
+            type: opts.type,
+            provider,
+            onStage: opts.json
+                ? undefined
+                : (stage) => console.log(STAGE_MESSAGES[stage]),
+        });
+        if (opts.json) {
+            reportJson(result);
+        }
+        else {
+            reportConsole(result);
+        }
+        process.exitCode = isMergeReady(result.score) ? 0 : 1;
+    }
+    catch (err) {
+        if (err instanceof NoChangesError) {
+            console.error(colors.yellow(err.message));
+            process.exitCode = 0;
+            return;
+        }
+        console.error(colors.red(err instanceof Error ? err.message : String(err)));
+        process.exitCode = 2;
+    }
+}

package/dist/config/credentialStore.js

@@ -0,0 +1,118 @@
+/**
+ * Local, encrypted credential store for provider API keys.
+ *
+ * CLI flags and env vars are per-invocation. This store lets a user pass
+ * --api-key/--model once and have it picked up automatically on every later
+ * run, without re-exporting an env var each time.
+ *
+ * The encryption key is a random 32-byte value generated on first use and
+ * kept in a file (key) separate from the ciphertext (credentials.json),
+ * both under the user's home directory with owner-only permissions. This
+ * guards against accidental exposure (e.g. a backup or sync tool scooping up
+ * one file but not the other) - it does not protect against an attacker who
+ * already has read access to the user's home directory, since the key lives
+ * on the same machine as the ciphertext.
+ */
+import { createCipheriv, createDecipheriv, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import path from "node:path";
+const CONFIG_DIR = path.join(homedir(), ".can-i-merge");
+const KEY_FILE = path.join(CONFIG_DIR, "key");
+const CREDENTIALS_FILE = path.join(CONFIG_DIR, "credentials.json");
+const ALGORITHM = "aes-256-gcm";
+function ensureConfigDir() {
+    if (!existsSync(CONFIG_DIR)) {
+        mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+function getOrCreateKey() {
+    ensureConfigDir();
+    if (existsSync(KEY_FILE)) {
+        return Buffer.from(readFileSync(KEY_FILE, "utf8"), "base64");
+    }
+    const key = randomBytes(32);
+    writeFileSync(KEY_FILE, key.toString("base64"), { mode: 0o600 });
+    return key;
+}
+function encrypt(plaintext, key) {
+    const iv = randomBytes(12);
+    const cipher = createCipheriv(ALGORITHM, key, iv);
+    const data = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    return {
+        iv: iv.toString("base64"),
+        tag: cipher.getAuthTag().toString("base64"),
+        data: data.toString("base64"),
+    };
+}
+function decrypt(value, key) {
+    const decipher = createDecipheriv(ALGORITHM, key, Buffer.from(value.iv, "base64"));
+    decipher.setAuthTag(Buffer.from(value.tag, "base64"));
+    const data = Buffer.concat([
+        decipher.update(Buffer.from(value.data, "base64")),
+        decipher.final(),
+    ]);
+    return data.toString("utf8");
+}
+function readCredentialsFile() {
+    if (!existsSync(CREDENTIALS_FILE)) {
+        return {};
+    }
+    try {
+        return JSON.parse(readFileSync(CREDENTIALS_FILE, "utf8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeCredentialsFile(contents) {
+    ensureConfigDir();
+    writeFileSync(CREDENTIALS_FILE, JSON.stringify(contents, null, 2), { mode: 0o600 });
+}
+/** Persist an API key and/or model for a provider, encrypting the API key at rest. */
+export function saveProviderConfig(provider, config) {
+    const file = readCredentialsFile();
+    const next = { ...file[provider] };
+    if (config.apiKey !== undefined) {
+        next.apiKey = encrypt(config.apiKey, getOrCreateKey());
+    }
+    if (config.model !== undefined) {
+        next.model = config.model;
+    }
+    file[provider] = next;
+    writeCredentialsFile(file);
+}
+/** Load a previously persisted API key/model for a provider, decrypting the API key. */
+export function loadProviderConfig(provider) {
+    const stored = readCredentialsFile()[provider];
+    if (!stored) {
+        return {};
+    }
+    const result = {};
+    if (stored.apiKey) {
+        try {
+            result.apiKey = decrypt(stored.apiKey, getOrCreateKey());
+        }
+        catch {
+            // Key file missing/rotated or ciphertext corrupted - treat as absent
+            // rather than crashing the CLI.
+        }
+    }
+    if (stored.model) {
+        result.model = stored.model;
+    }
+    return result;
+}
+/** Remove stored credentials for a provider (or all providers if omitted). */
+export function clearProviderConfig(provider) {
+    if (!existsSync(CREDENTIALS_FILE)) {
+        return;
+    }
+    if (!provider) {
+        unlinkSync(CREDENTIALS_FILE);
+        return;
+    }
+    const file = readCredentialsFile();
+    delete file[provider];
+    writeCredentialsFile(file);
+}

package/dist/config/index.js

@@ -0,0 +1,4 @@
+/**
+ * config package entry point. Re-exports the encrypted credential store.
+ */
+export * from "./credentialStore.js";

package/dist/context-engine/contextBudgetEngine.js

@@ -0,0 +1,40 @@
+/**
+ * Context Budget Engine
+ *
+ * Context Builder operates on a TOKEN BUDGET, not a fixed depth. The git
+ * diff itself is always included in full and its token cost is reserved off
+ * the top; the budget only decides how many extra *related* files get
+ * pulled in around it.
+ */
+import { estimateTokens } from "../shared/tokens.js";
+export const DEFAULT_BUDGET = {
+    maxTokens: 12000,
+    maxFiles: 15,
+    reservedDiffTokens: 3000,
+};
+export function applyBudget(relatedFiles, diffText, budget) {
+    const diffTokens = Math.max(estimateTokens(diffText), budget.reservedDiffTokens);
+    const sorted = [...relatedFiles].sort((a, b) => b.score - a.score);
+    const included = [];
+    let truncated = false;
+    let includedTokens = 0;
+    for (const candidate of sorted) {
+        if (included.length + 1 > budget.maxFiles) {
+            truncated = true;
+            continue;
+        }
+        const candidateTokens = estimateTokens(candidate.content);
+        const remaining = budget.maxTokens - diffTokens - includedTokens;
+        if (candidateTokens > remaining) {
+            truncated = true;
+            continue;
+        }
+        included.push(candidate);
+        includedTokens += candidateTokens;
+    }
+    return {
+        included,
+        truncated,
+        tokenEstimate: diffTokens + includedTokens,
+    };
+}