can-i-merge 0.1.0 → 0.1.1

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,121 @@
+/**
+ * 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 { 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 { 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...",
+};
+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));
+    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")
+        .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.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;
+    }
+    const registry = buildProviderRegistry();
+    let provider;
+    try {
+        provider = registry.create(opts.provider);
+    }
+    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/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,
+    };
+}

package/dist/context-engine/contextBuilder.js

@@ -0,0 +1,182 @@
+/**
+ * Context Builder - main entry point for the Context Engine.
+ *
+ * Orchestrates dependency resolution, scoring and budgeting to produce a
+ * ReviewContext for the Prompt Builder. The git diff is always included in
+ * full; the token budget only governs how many extra related files are
+ * pulled in around it.
+ */
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import { estimateTokens } from "../shared/tokens.js";
+import { applyBudget, DEFAULT_BUDGET } from "./contextBudgetEngine.js";
+import { scoreCandidates } from "./contextScoreEngine.js";
+import { resolveDependencies } from "./dependencyResolver.js";
+const TEST_EXTENSION_SUFFIXES = [
+    ".test.ts",
+    ".test.tsx",
+    ".spec.ts",
+    ".spec.tsx",
+];
+const ROOT_CONFIG_FILES = [
+    "tsconfig.json",
+    "package.json",
+    ".eslintrc.json",
+    ".eslintrc.cjs",
+    ".eslintrc.js",
+];
+const MAX_CONFIG_FILE_BYTES = 50_000;
+function toPosixPath(p) {
+    return p.split(path.sep).join("/");
+}
+async function readFileIfSmallEnough(absPath, maxBytes) {
+    try {
+        const stat = await fs.stat(absPath);
+        if (!stat.isFile())
+            return undefined;
+        if (stat.size > maxBytes)
+            return undefined;
+        return await fs.readFile(absPath, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+function stripKnownExtension(filePath) {
+    const ext = path.extname(filePath);
+    return ext ? filePath.slice(0, -ext.length) : filePath;
+}
+async function findTestFileFor(changedFile, repoRoot) {
+    const base = stripKnownExtension(changedFile);
+    const dir = path.dirname(changedFile);
+    const baseName = path.basename(base);
+    const candidateRelPaths = [];
+    for (const suffix of TEST_EXTENSION_SUFFIXES) {
+        candidateRelPaths.push(toPosixPath(base + suffix));
+    }
+    for (const suffix of TEST_EXTENSION_SUFFIXES) {
+        candidateRelPaths.push(toPosixPath(path.join(dir, "__tests__", baseName + suffix)));
+    }
+    for (const relPath of candidateRelPaths) {
+        if (relPath === changedFile)
+            continue;
+        const absPath = path.join(repoRoot, relPath);
+        const content = await readFileIfSmallEnough(absPath, 200_000);
+        if (content !== undefined) {
+            return {
+                file: relPath,
+                content,
+                reason: `test file for ${changedFile}`,
+                score: 65,
+            };
+        }
+    }
+    return undefined;
+}
+async function gatherDeepExtras(changedFiles, repoRoot, existingFiles) {
+    const extras = [];
+    const seen = new Set(existingFiles);
+    for (const changed of changedFiles) {
+        if (changed.status === "deleted")
+            continue;
+        const testFile = await findTestFileFor(changed.file, repoRoot);
+        if (testFile && !seen.has(testFile.file)) {
+            extras.push(testFile);
+            seen.add(testFile.file);
+        }
+    }
+    for (const configFile of ROOT_CONFIG_FILES) {
+        if (seen.has(configFile))
+            continue;
+        const absPath = path.join(repoRoot, configFile);
+        const content = await readFileIfSmallEnough(absPath, MAX_CONFIG_FILE_BYTES);
+        if (content !== undefined) {
+            extras.push({
+                file: configFile,
+                content,
+                reason: "project config",
+                score: 55,
+            });
+            seen.add(configFile);
+        }
+    }
+    return extras;
+}
+async function loadProjectRules(repoRoot) {
+    try {
+        const configPath = path.join(repoRoot, "can-i-merge.config.json");
+        const configContent = await readFileIfSmallEnough(configPath, MAX_CONFIG_FILE_BYTES);
+        if (configContent !== undefined) {
+            const parsed = JSON.parse(configContent);
+            if (parsed &&
+                typeof parsed === "object" &&
+                "rules" in parsed &&
+                typeof parsed.rules === "string") {
+                return parsed.rules;
+            }
+        }
+    }
+    catch {
+        // fall through to next strategy - malformed config should not throw
+    }
+    try {
+        const rulesPath = path.join(repoRoot, ".can-i-merge", "rules.md");
+        const rulesContent = await fs.readFile(rulesPath, "utf8");
+        return rulesContent;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function buildContext(changedFiles, options) {
+    const budget = { ...DEFAULT_BUDGET, ...options.budget };
+    const diff = changedFiles.map((c) => c.diff).join("\n\n");
+    let scored = [];
+    if (options.level !== "fast") {
+        const maxDepth = options.level === "deep" ? 3 : 2;
+        const candidates = await resolveDependencies(changedFiles, options.repoRoot, {
+            maxDepth,
+        });
+        scored = scoreCandidates(candidates);
+        if (options.level === "deep") {
+            const existingFiles = new Set(scored.map((f) => f.file));
+            const extras = await gatherDeepExtras(changedFiles, options.repoRoot, existingFiles);
+            scored = [...scored, ...extras];
+        }
+    }
+    let relatedFiles;
+    let tokenEstimate;
+    let truncated;
+    if (options.level !== "fast") {
+        const budgetResult = applyBudget(scored, diff, budget);
+        relatedFiles = budgetResult.included;
+        tokenEstimate = budgetResult.tokenEstimate;
+        truncated = budgetResult.truncated;
+    }
+    else {
+        relatedFiles = [];
+        tokenEstimate = estimateTokens(diff);
+        truncated = false;
+    }
+    let projectRules;
+    if (options.projectRules !== undefined) {
+        projectRules = options.projectRules;
+    }
+    else {
+        projectRules = await loadProjectRules(options.repoRoot);
+    }
+    return {
+        level: options.level,
+        type: options.type,
+        diff,
+        changedFiles,
+        relatedFiles,
+        projectRules,
+        prompt: undefined,
+        budget,
+        meta: {
+            tokenEstimate,
+            truncated,
+        },
+    };
+}

package/dist/context-engine/contextScoreEngine.js

@@ -0,0 +1,19 @@
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+export function scoreCandidates(candidates) {
+    return candidates.map((candidate) => {
+        const proximityScore = Math.max(10, 100 - (candidate.distance - 1) * 30);
+        const referenceBonus = Math.min(candidate.referencedBy.length, 5) * 5;
+        const score = clamp(proximityScore + referenceBonus, 0, 100);
+        const reason = candidate.referencedBy.length
+            ? `referenced by ${candidate.referencedBy.join(", ")}`
+            : "related file";
+        return {
+            file: candidate.file,
+            content: candidate.content,
+            reason,
+            score,
+        };
+    });
+}