kanzaki 0.2.0

package/dist/bin.js

@@ -0,0 +1,1106 @@
+#!/usr/bin/env node
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk2 from "chalk";
+import { existsSync as existsSync5, writeFileSync as writeFileSync3, readFileSync as readFileSync4, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve4, dirname } from "path";
+import { fileURLToPath } from "url";
+import { createInterface } from "readline";
+import { execSync as execSync2 } from "child_process";
+
+// src/config.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve as resolve2 } from "path";
+import dotenv from "dotenv";
+
+// src/auth.ts
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+import { createServer } from "http";
+import { randomBytes, createHash } from "crypto";
+import open from "open";
+var CONFIG_DIR = resolve(homedir(), ".config", "kanzaki");
+var CREDENTIALS_PATH = resolve(CONFIG_DIR, "credentials.json");
+function loadCredentials() {
+  if (!existsSync(CREDENTIALS_PATH)) return null;
+  try {
+    const raw = readFileSync(CREDENTIALS_PATH, "utf-8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+function saveCredentials(credentials) {
+  if (!existsSync(CONFIG_DIR)) {
+    mkdirSync(CONFIG_DIR, { recursive: true });
+  }
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(credentials, null, 2), "utf-8");
+}
+function clearCredentials() {
+  if (existsSync(CREDENTIALS_PATH)) {
+    writeFileSync(CREDENTIALS_PATH, "{}", "utf-8");
+  }
+}
+function getActiveApiKey(creds) {
+  if (creds.useClaudeCli) {
+    return "claude-cli";
+  }
+  if (creds.oauthToken) {
+    if (!creds.expiresAt) {
+      return creds.oauthToken;
+    }
+    const expiry = new Date(creds.expiresAt);
+    if (expiry > /* @__PURE__ */ new Date()) {
+      return creds.oauthToken;
+    }
+  }
+  return creds.apiKey;
+}
+var OPENAI_AUTH_URL = "https://auth.openai.com/oauth/authorize";
+var OPENAI_TOKEN_URL = "https://auth.openai.com/oauth/token";
+var OPENAI_CLIENT_ID = "app_EMoamEEZ73f0CkXaXp7hrann";
+var REDIRECT_URI = "http://localhost:1455/auth/callback";
+function generatePKCE() {
+  const verifier = randomBytes(32).toString("base64url");
+  const challenge = createHash("sha256").update(verifier).digest("base64url");
+  return { verifier, challenge };
+}
+async function loginWithOAuthPKCE() {
+  const { verifier, challenge } = generatePKCE();
+  const state = randomBytes(16).toString("base64url");
+  const scope = encodeURIComponent("openid profile email offline_access api.connectors.read api.connectors.invoke");
+  const authUrl = `${OPENAI_AUTH_URL}?response_type=code&client_id=${OPENAI_CLIENT_ID}&code_challenge=${challenge}&code_challenge_method=S256&redirect_uri=${encodeURIComponent(REDIRECT_URI)}&scope=${scope}&state=${state}&id_token_add_organizations=true&codex_cli_simplified_flow=true`;
+  console.log("Opening browser for authentication...");
+  console.log("If your browser does not open automatically, please open this link:");
+  console.log(authUrl);
+  try {
+    await open(authUrl);
+  } catch {
+  }
+  return new Promise((resolve5, reject) => {
+    const server = createServer(async (req, res) => {
+      try {
+        if (!req.url?.startsWith("/auth/callback")) {
+          res.writeHead(404);
+          res.end("Not found");
+          return;
+        }
+        const url = new URL(req.url, `http://${req.headers.host}`);
+        const error = url.searchParams.get("error");
+        const errorDesc = url.searchParams.get("error_description");
+        const code = url.searchParams.get("code");
+        const returnedState = url.searchParams.get("state");
+        if (error) {
+          res.writeHead(400, { "Content-Type": "text/html" });
+          res.end(`<h1>Authentication Failed</h1><p>${error}: ${errorDesc || "Unknown error"}</p>`);
+          server.close();
+          return reject(new Error(`OAuth error: ${error} - ${errorDesc}`));
+        }
+        if (!code) {
+          res.writeHead(400);
+          res.end("Missing authorization code");
+          server.close();
+          return reject(new Error("No authorization code received"));
+        }
+        if (returnedState !== state) {
+          res.writeHead(400);
+          res.end("Invalid state");
+          server.close();
+          return reject(new Error("OAuth state mismatch"));
+        }
+        res.writeHead(200, { "Content-Type": "text/html" });
+        res.end("<h1>Authentication Successful!</h1><p>You can close this tab and return to your terminal.</p>");
+        server.close();
+        const tokenRes = await fetch(OPENAI_TOKEN_URL, {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({
+            client_id: OPENAI_CLIENT_ID,
+            grant_type: "authorization_code",
+            code,
+            code_verifier: verifier,
+            redirect_uri: REDIRECT_URI
+          })
+        });
+        if (!tokenRes.ok) {
+          const body = await tokenRes.text();
+          return reject(new Error(`Token exchange failed: ${tokenRes.status} ${body}`));
+        }
+        const tokenData = await tokenRes.json();
+        resolve5(tokenData);
+      } catch (err) {
+        res.writeHead(500);
+        res.end("Internal Server Error");
+        server.close();
+        reject(err);
+      }
+    });
+    server.listen(1455, "localhost");
+  });
+}
+
+// src/config.ts
+var DEFAULT_MODELS = {
+  openai: "gpt-5.4",
+  anthropic: "claude-sonnet-4-20250514"
+};
+function loadConfig(overrides = {}) {
+  const envPath = resolve2(process.cwd(), ".env");
+  if (existsSync2(envPath)) {
+    dotenv.config({ path: envPath });
+  }
+  const stored = loadCredentials();
+  const provider = overrides.provider ?? process.env.KANZAKI_PROVIDER ?? stored?.provider ?? "openai";
+  let apiKey = overrides.apiKey ?? process.env.KANZAKI_API_KEY ?? "";
+  if (!apiKey && stored) {
+    apiKey = getActiveApiKey(stored);
+  }
+  if (!apiKey) {
+    throw new Error(
+      "API key is required. Run 'kanzaki login' or set KANZAKI_API_KEY environment variable."
+    );
+  }
+  const model = overrides.model ?? process.env.KANZAKI_MODEL ?? DEFAULT_MODELS[provider] ?? "gpt-5.4";
+  const rulesPath = overrides.rulesPath ?? process.env.KANZAKI_RULES_PATH ?? ".kanzaki/rules.md";
+  return {
+    provider,
+    apiKey,
+    model,
+    rulesPath: resolve2(process.cwd(), rulesPath),
+    verbose: overrides.verbose ?? false,
+    noBlock: overrides.noBlock ?? false,
+    useOAuth: !!stored?.oauthToken,
+    useClaudeCli: !!stored?.useClaudeCli
+  };
+}
+
+// src/core/parser.ts
+import { readFileSync as readFileSync2 } from "fs";
+function parseRulesFile(filePath) {
+  const content = readFileSync2(filePath, "utf-8");
+  return parseRulesFromContent(content);
+}
+function parseRulesFromContent(content) {
+  const lines = content.split("\n");
+  const rules = [];
+  const contextLines = [];
+  const errors = [];
+  let currentGroup = "General";
+  let currentPatterns = [];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    const lineNumber = i + 1;
+    const headerMatch = trimmed.match(/^#{1,6}\s+(.+)$/);
+    if (headerMatch) {
+      const headerText = headerMatch[1].trim();
+      const { name, patterns } = parseHeaderWithPatterns(headerText);
+      currentGroup = name;
+      currentPatterns = patterns;
+      if (headerText.includes("(") && !headerText.includes(")")) {
+        errors.push({ line: lineNumber, message: `Missing closing parenthesis in file scope: "${headerText}"` });
+      }
+      const emptyParenMatch = headerText.match(/\(\s*\)/);
+      if (emptyParenMatch) {
+        errors.push({ line: lineNumber, message: `Empty file scope parentheses: "${headerText}". Remove "()" or specify glob patterns inside.` });
+      }
+      continue;
+    }
+    const emptyRuleMatch = trimmed.match(/^-\s*\[[\s]?\]\s*$/);
+    if (emptyRuleMatch) {
+      errors.push({ line: lineNumber, message: `Empty rule. Checklist item has no text.` });
+      continue;
+    }
+    const ruleMatch = trimmed.match(/^-\s*\[[\s]?\]\s+(.+)$/);
+    if (ruleMatch) {
+      const rawText = ruleMatch[1].trim();
+      const invalidTagMatch = rawText.match(/^!(err|warning|info|critical|block)\b/i);
+      if (invalidTagMatch) {
+        errors.push({ line: lineNumber, message: `Unknown severity tag "${invalidTagMatch[0]}". Use !error or !warn.` });
+      }
+      const { severity, text } = parseSeverity(rawText);
+      if (text.length === 0) {
+        errors.push({ line: lineNumber, message: `Empty rule. Checklist item has only a severity tag with no description.` });
+        continue;
+      }
+      rules.push({
+        group: currentGroup,
+        text,
+        severity,
+        filePatterns: currentPatterns,
+        lineNumber
+      });
+      continue;
+    }
+    if (trimmed.length > 0) {
+      if (trimmed.match(/^[-*+]\s*\[(.*?)\]/)) {
+        errors.push({ line: lineNumber, message: `Invalid rule format. Checkbox must be '- [ ]'. Found: "${trimmed}"` });
+      }
+      contextLines.push(trimmed);
+    }
+  }
+  const seen = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const key = `${rule.group}\0${rule.text.toLowerCase()}`;
+    const firstLine = seen.get(key);
+    if (firstLine !== void 0) {
+      errors.push({
+        line: rule.lineNumber ?? 0,
+        message: `Duplicate rule in group "${rule.group}" (first defined at line ${firstLine}): "${rule.text}"`
+      });
+    } else {
+      seen.set(key, rule.lineNumber ?? 0);
+    }
+  }
+  return {
+    rules,
+    context: contextLines.join("\n"),
+    errors
+  };
+}
+function parseHeaderWithPatterns(header) {
+  const match = header.match(/^(.+?)\s*\(([^)]+)\)\s*$/);
+  if (match) {
+    const name = match[1].trim();
+    const patterns = match[2].split(",").map((p) => p.trim()).filter(Boolean);
+    return { name, patterns };
+  }
+  return { name: header, patterns: [] };
+}
+function parseSeverity(rawText) {
+  const warnMatch = rawText.match(/^!warn\s+(.+)$/i);
+  if (warnMatch) {
+    return { severity: "warn", text: warnMatch[1].trim() };
+  }
+  const errorMatch = rawText.match(/^!error\s+(.+)$/i);
+  if (errorMatch) {
+    return { severity: "error", text: errorMatch[1].trim() };
+  }
+  return { severity: "error", text: rawText };
+}
+function formatRulesForPrompt(rules) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    const group = grouped.get(rule.group) ?? [];
+    group.push(rule);
+    grouped.set(rule.group, group);
+  }
+  const sections = [];
+  for (const [group, groupRules] of grouped) {
+    const scope = groupRules[0]?.filePatterns.length > 0 ? ` (applies to: ${groupRules[0].filePatterns.join(", ")})` : "";
+    sections.push(`### ${group}${scope}`);
+    for (let i = 0; i < groupRules.length; i++) {
+      const r = groupRules[i];
+      const tag = r.severity === "warn" ? "[WARNING]" : "[ERROR]";
+      sections.push(`${i + 1}. ${tag} ${r.text}`);
+    }
+    sections.push("");
+  }
+  return sections.join("\n");
+}
+function filterRulesByFiles(rules, changedFiles) {
+  return rules.filter((rule) => {
+    if (rule.filePatterns.length === 0) return true;
+    return changedFiles.some(
+      (file) => rule.filePatterns.some((pattern) => matchGlob(file, pattern))
+    );
+  });
+}
+function matchGlob(filePath, pattern) {
+  const regexStr = pattern.replace(/\./g, "\\.").replace(/\*\*/g, "{{DOUBLE_STAR}}").replace(/\*/g, "[^/]*").replace(/{{DOUBLE_STAR}}/g, ".*").replace(/\?/g, "[^/]");
+  const regex = new RegExp(`(^|/)${regexStr}$`, "i");
+  return regex.test(filePath);
+}
+
+// src/core/git.ts
+import { execSync } from "child_process";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { resolve as resolve3 } from "path";
+function getStagedChanges() {
+  const diff = exec("git diff --staged");
+  const filesRaw = exec("git diff --staged --name-only");
+  const files = filesRaw.split("\n").map((f) => f.trim()).filter(Boolean);
+  return { diff, files };
+}
+function getFileContexts(files) {
+  const repoRoot = getRepoRoot();
+  const contexts = [];
+  for (const file of files) {
+    const absPath = resolve3(repoRoot, file);
+    if (!existsSync3(absPath)) continue;
+    if (isBinaryPath(file)) continue;
+    try {
+      const content = readFileSync3(absPath, "utf-8");
+      if (content.length > 1e5) continue;
+      contexts.push({ path: file, content });
+    } catch {
+    }
+  }
+  return contexts;
+}
+function getRepoRoot() {
+  return exec("git rev-parse --show-toplevel").trim();
+}
+function hasStagedChanges() {
+  const output = exec("git diff --staged --name-only");
+  return output.trim().length > 0;
+}
+function exec(command) {
+  try {
+    return execSync(command, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+  } catch (error) {
+    const err = error;
+    throw new Error(`Git command failed: ${command}
+${err.stderr ?? err.message}`);
+  }
+}
+var BINARY_EXTENSIONS = /* @__PURE__ */ new Set([
+  ".png",
+  ".jpg",
+  ".jpeg",
+  ".gif",
+  ".bmp",
+  ".ico",
+  ".webp",
+  ".svg",
+  ".mp4",
+  ".webm",
+  ".mov",
+  ".avi",
+  ".mp3",
+  ".wav",
+  ".ogg",
+  ".zip",
+  ".tar",
+  ".gz",
+  ".rar",
+  ".7z",
+  ".pdf",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".woff",
+  ".woff2",
+  ".ttf",
+  ".eot",
+  ".otf",
+  ".exe",
+  ".dll",
+  ".so",
+  ".dylib",
+  ".lock"
+]);
+function isBinaryPath(filePath) {
+  const ext = filePath.slice(filePath.lastIndexOf(".")).toLowerCase();
+  return BINARY_EXTENSIONS.has(ext);
+}
+
+// src/llm/openai.ts
+import OpenAI from "openai";
+var CHATGPT_BASE_URL = "https://chatgpt.com/backend-api/codex";
+var OpenAIProvider = class {
+  apiKey;
+  model;
+  useOAuth;
+  constructor(apiKey, model, useOAuth = false) {
+    this.apiKey = apiKey;
+    this.model = model;
+    this.useOAuth = useOAuth;
+  }
+  async review(systemPrompt, userPrompt) {
+    if (this.useOAuth) {
+      return this.reviewWithCodexBackend(systemPrompt, userPrompt);
+    }
+    return this.reviewWithChatCompletions(systemPrompt, userPrompt);
+  }
+  async reviewWithChatCompletions(systemPrompt, userPrompt) {
+    const client = new OpenAI({ apiKey: this.apiKey });
+    const response = await client.chat.completions.create({
+      model: this.model,
+      messages: [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: userPrompt }
+      ],
+      response_format: { type: "json_object" },
+      temperature: 0.1
+    });
+    const content = response.choices[0]?.message?.content;
+    if (!content) {
+      throw new Error("OpenAI returned an empty response.");
+    }
+    return parseReviewResponse(content);
+  }
+  async reviewWithCodexBackend(systemPrompt, userPrompt) {
+    const url = `${CHATGPT_BASE_URL}/responses`;
+    const body = {
+      model: this.model,
+      instructions: systemPrompt,
+      input: [
+        { role: "user", content: userPrompt }
+      ],
+      store: false,
+      stream: true
+    };
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.apiKey}`
+      },
+      body: JSON.stringify(body)
+    });
+    if (!res.ok) {
+      const errorBody = await res.text();
+      throw new Error(`${res.status} ${errorBody}`);
+    }
+    const content = await this.readSSEStream(res);
+    return parseReviewResponse(content);
+  }
+  async readSSEStream(res) {
+    const reader = res.body?.getReader();
+    if (!reader) {
+      throw new Error("No response body");
+    }
+    const decoder = new TextDecoder();
+    let content = "";
+    let buffer = "";
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      buffer += decoder.decode(value, { stream: true });
+      const lines = buffer.split("\n");
+      buffer = lines.pop() ?? "";
+      for (const line of lines) {
+        if (!line.startsWith("data: ")) continue;
+        const data = line.slice(6).trim();
+        if (data === "[DONE]") continue;
+        try {
+          const event = JSON.parse(data);
+          if (event.type === "response.output_text.delta" && event.delta) {
+            content += event.delta;
+          }
+        } catch {
+        }
+      }
+    }
+    if (!content) {
+      throw new Error("OpenAI returned an empty response from stream.");
+    }
+    return content;
+  }
+};
+function parseReviewResponse(raw) {
+  try {
+    const parsed = JSON.parse(raw);
+    if (!Array.isArray(parsed.results)) {
+      throw new Error("Response missing 'results' array.");
+    }
+    return {
+      results: parsed.results.map((r) => ({
+        rule: String(r.rule ?? ""),
+        passed: Boolean(r.passed),
+        reason: String(r.reason ?? "")
+      })),
+      summary: String(parsed.summary ?? "")
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse LLM response as JSON:
+${raw}
+
+${error}`);
+  }
+}
+
+// src/llm/anthropic.ts
+import Anthropic from "@anthropic-ai/sdk";
+var AnthropicProvider = class {
+  client;
+  model;
+  constructor(apiKey, model) {
+    this.client = new Anthropic({ apiKey });
+    this.model = model;
+  }
+  async review(systemPrompt, userPrompt) {
+    const response = await this.client.messages.create({
+      model: this.model,
+      max_tokens: 4096,
+      system: systemPrompt,
+      messages: [{ role: "user", content: userPrompt }]
+    });
+    const textBlock = response.content.find((b) => b.type === "text");
+    if (!textBlock || textBlock.type !== "text") {
+      throw new Error("Anthropic returned no text content.");
+    }
+    return parseReviewResponse2(textBlock.text);
+  }
+};
+function parseReviewResponse2(raw) {
+  const jsonMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const jsonStr = jsonMatch ? jsonMatch[1].trim() : raw.trim();
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed.results)) {
+      throw new Error("Response missing 'results' array.");
+    }
+    return {
+      results: parsed.results.map((r) => ({
+        rule: String(r.rule ?? ""),
+        passed: Boolean(r.passed),
+        reason: String(r.reason ?? "")
+      })),
+      summary: String(parsed.summary ?? "")
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse LLM response as JSON:
+${raw}
+
+${error}`);
+  }
+}
+
+// src/llm/claude-cli.ts
+import { spawn } from "child_process";
+var ClaudeCliProvider = class {
+  async review(systemPrompt, userPrompt) {
+    const combinedPrompt = `${systemPrompt}
+
+---
+
+${userPrompt}`;
+    const output = await this.runClaudeCli(combinedPrompt);
+    return parseReviewResponse3(output);
+  }
+  runClaudeCli(prompt) {
+    return new Promise((resolve5, reject) => {
+      const isWin = process.platform === "win32";
+      const child = isWin ? spawn("cmd.exe", ["/d", "/s", "/c", "claude -p"], {
+        stdio: ["pipe", "pipe", "pipe"],
+        windowsVerbatimArguments: true
+      }) : spawn("claude", ["-p"], {
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      let stdout = "";
+      let stderr = "";
+      child.stdout.on("data", (chunk) => {
+        stdout += chunk.toString("utf-8");
+      });
+      child.stderr.on("data", (chunk) => {
+        stderr += chunk.toString("utf-8");
+      });
+      child.on("error", (err) => {
+        reject(new Error(`Failed to spawn claude CLI: ${err.message}`));
+      });
+      child.on("close", (code) => {
+        if (code !== 0) {
+          reject(new Error(`claude CLI exited with code ${code}: ${stderr || stdout}`));
+          return;
+        }
+        resolve5(stdout);
+      });
+      child.stdin.write(prompt);
+      child.stdin.end();
+    });
+  }
+};
+function parseReviewResponse3(raw) {
+  const jsonMatch = raw.match(/```(?:json)?\s*([\s\S]*?)```/);
+  const jsonStr = jsonMatch ? jsonMatch[1].trim() : raw.trim();
+  try {
+    const parsed = JSON.parse(jsonStr);
+    if (!Array.isArray(parsed.results)) {
+      throw new Error("Response missing 'results' array.");
+    }
+    return {
+      results: parsed.results.map((r) => ({
+        rule: String(r.rule ?? ""),
+        passed: Boolean(r.passed),
+        reason: String(r.reason ?? "")
+      })),
+      summary: String(parsed.summary ?? "")
+    };
+  } catch (error) {
+    throw new Error(`Failed to parse Claude CLI response as JSON:
+${raw}
+
+${error}`);
+  }
+}
+
+// src/core/reviewer.ts
+var SYSTEM_PROMPT = `You are a strict quality reviewer. Your job is to review changes (git diff) against a checklist of rules defined by the user.
+
+The rules may cover ANY domain \u2014 code, documentation, research, writing, presentations, design, or any other type of output. Evaluate each rule based on its intent, not just literal text matching.
+
+For each rule in the checklist, determine whether the staged changes comply with it.
+
+IMPORTANT:
+- Rules marked [ERROR] are critical. Be strict when evaluating them.
+- Rules marked [WARNING] are advisory. Be fair but flag clear violations.
+- Only evaluate rules that are RELEVANT to the changes. If a rule clearly does not apply to the content being changed, mark it as passed with reason "Not applicable to these changes."
+- Use the context section (if provided) to understand the project's goals and constraints.
+- Look at both the diff AND the full file context to make accurate judgments.
+
+You MUST respond with valid JSON in this exact format:
+{
+  "results": [
+    { "rule": "<exact rule text>", "passed": true, "reason": "<brief explanation>" },
+    { "rule": "<exact rule text>", "passed": false, "reason": "<specific explanation of the violation>" }
+  ],
+  "summary": "<one-line overall summary>"
+}`;
+async function review(config, rules, staged, fileContexts, rulesContext) {
+  const provider = createProvider(config);
+  const userPrompt = buildUserPrompt(rules, staged, fileContexts, rulesContext);
+  const rawResult = await provider.review(SYSTEM_PROMPT, userPrompt);
+  return mapSeverities(rawResult, rules);
+}
+function createProvider(config) {
+  switch (config.provider) {
+    case "openai":
+      return new OpenAIProvider(config.apiKey, config.model, config.useOAuth);
+    case "anthropic":
+      if (config.useClaudeCli) {
+        return new ClaudeCliProvider();
+      }
+      return new AnthropicProvider(config.apiKey, config.model);
+    default:
+      throw new Error(`Unknown provider: ${config.provider}`);
+  }
+}
+function buildUserPrompt(rules, staged, fileContexts, rulesContext) {
+  const parts = [];
+  if (rulesContext && rulesContext.trim().length > 0) {
+    parts.push("## Project Context\n");
+    parts.push(rulesContext);
+    parts.push("");
+  }
+  parts.push("## Checklist Rules\n");
+  parts.push(formatRulesForPrompt(rules));
+  parts.push("## Staged Changes (git diff)\n");
+  parts.push("```diff");
+  parts.push(truncate(staged.diff, 5e4));
+  parts.push("```\n");
+  if (fileContexts.length > 0) {
+    parts.push("## Full File Context\n");
+    parts.push("The following are the full contents of modified files for additional context:\n");
+    for (const ctx of fileContexts) {
+      const ext = ctx.path.split(".").pop() ?? "";
+      parts.push(`### ${ctx.path}
+`);
+      parts.push(`\`\`\`${ext}`);
+      parts.push(truncate(ctx.content, 2e4));
+      parts.push("```\n");
+    }
+  }
+  return parts.join("\n");
+}
+function mapSeverities(result, rules) {
+  const severityMap = /* @__PURE__ */ new Map();
+  for (const rule of rules) {
+    severityMap.set(rule.text.toLowerCase(), rule.severity);
+  }
+  return {
+    ...result,
+    results: result.results.map((r) => ({
+      ...r,
+      severity: severityMap.get(r.rule.toLowerCase()) ?? "error"
+    }))
+  };
+}
+function truncate(text, maxLength) {
+  if (text.length <= maxLength) return text;
+  return text.slice(0, maxLength) + "\n\n... (truncated)";
+}
+
+// src/core/reporter.ts
+import chalk from "chalk";
+function report(result, verbose) {
+  const { results, summary } = result;
+  console.log();
+  console.log(chalk.bold.underline("Kanzaki Review Results"));
+  console.log();
+  let errorCount = 0;
+  let warnCount = 0;
+  for (const r of results) {
+    const isWarn = r.severity === "warn";
+    const label = isWarn ? chalk.dim("[warn]") : chalk.dim("[error]");
+    if (r.passed) {
+      console.log(`  ${chalk.green("\u2713")} ${label} ${r.rule}`);
+      if (verbose) {
+        console.log(`    ${chalk.dim(r.reason)}`);
+      }
+    } else {
+      if (isWarn) {
+        warnCount++;
+        console.log(`  ${chalk.yellow("\u26A0")} ${label} ${r.rule}`);
+        console.log(`    ${chalk.yellow("\u2192")} ${r.reason}`);
+      } else {
+        errorCount++;
+        console.log(`  ${chalk.red("\u2717")} ${label} ${r.rule}`);
+        console.log(`    ${chalk.red("\u2192")} ${r.reason}`);
+      }
+    }
+  }
+  console.log();
+  const total = results.length;
+  const passedCount = total - errorCount - warnCount;
+  if (errorCount === 0 && warnCount === 0) {
+    console.log(chalk.green.bold(`  All ${total} rules passed \u2713`));
+  } else {
+    const parts = [];
+    parts.push(`${passedCount}/${total} passed`);
+    if (errorCount > 0) parts.push(chalk.red(`${errorCount} errors`));
+    if (warnCount > 0) parts.push(chalk.yellow(`${warnCount} warnings`));
+    console.log(`  ${parts.join(", ")}`);
+    if (errorCount > 0) {
+      console.log(chalk.red.bold("\n  Commit blocked due to errors."));
+    } else {
+      console.log(chalk.yellow("\n  Warnings found, but commit allowed."));
+    }
+  }
+  if (summary) {
+    console.log();
+    console.log(chalk.dim(`  ${summary}`));
+  }
+  console.log();
+  return { errorCount, warnCount };
+}
+
+// src/core/feedback.ts
+import { mkdirSync as mkdirSync2, writeFileSync as writeFileSync2, existsSync as existsSync4 } from "fs";
+import { join } from "path";
+function writeFeedbackFile(result, rules, staged, outputDir) {
+  const failures = result.results.filter((r) => !r.passed);
+  if (failures.length === 0) return null;
+  if (!existsSync4(outputDir)) {
+    mkdirSync2(outputDir, { recursive: true });
+  }
+  const now = /* @__PURE__ */ new Date();
+  const filePath = join(outputDir, `${formatTimestamp(now)}.md`);
+  const content = buildFeedbackMarkdown(failures, rules, staged, now, result.summary);
+  writeFileSync2(filePath, content, "utf-8");
+  return filePath;
+}
+function buildFeedbackMarkdown(failures, rules, staged, now, summary) {
+  const ruleMap = /* @__PURE__ */ new Map();
+  for (const r of rules) {
+    ruleMap.set(r.text.toLowerCase(), r);
+  }
+  const errorCount = failures.filter((f) => f.severity === "error").length;
+  const warnCount = failures.filter((f) => f.severity === "warn").length;
+  const lines = [];
+  lines.push(`# Kanzaki Review Feedback`);
+  lines.push(``);
+  lines.push(`Generated: ${now.toISOString()}`);
+  lines.push(``);
+  lines.push(`## Summary`);
+  lines.push(``);
+  if (summary) {
+    lines.push(summary);
+    lines.push(``);
+  }
+  lines.push(`- \u30A8\u30E9\u30FC: ${errorCount} \u4EF6`);
+  lines.push(`- \u8B66\u544A: ${warnCount} \u4EF6`);
+  lines.push(`- \u5909\u66F4\u30D5\u30A1\u30A4\u30EB: ${staged.files.join(", ")}`);
+  lines.push(``);
+  lines.push(`## Instructions for Coding Agents`);
+  lines.push(``);
+  lines.push(`\u4EE5\u4E0B\u306F \`kanzaki check\` \u304C\u691C\u51FA\u3057\u305F\u30EB\u30FC\u30EB\u9055\u53CD\u3067\u3059\u3002\u5404\u9055\u53CD\u306B\u3064\u3044\u3066\u3001\u6307\u6458\u5185\u5BB9\u3092\u8AAD\u307F\u3001\u5BFE\u8C61\u30D5\u30A1\u30A4\u30EB\u306E\u8A72\u5F53\u7B87\u6240\u3092\u4FEE\u6B63\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+  lines.push(`\u4FEE\u6B63\u5F8C\u306F \`git add\` \u3067\u518D\u5EA6\u30B9\u30C6\u30FC\u30B8\u3057\u3001\`kanzaki check\` \u3092\u5B9F\u884C\u3057\u3066\u9055\u53CD\u304C\u89E3\u6D88\u3055\u308C\u305F\u3053\u3068\u3092\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\u3002`);
+  lines.push(`\u30EB\u30FC\u30EB\u5B9A\u7FA9\u305D\u306E\u3082\u306E\u3092\u5909\u66F4\u3059\u308B\u3053\u3068\u3067\u9055\u53CD\u3092\u56DE\u907F\u3059\u308B\u3053\u3068\u306F\u7981\u6B62\u3055\u308C\u3066\u3044\u307E\u3059\uFF08\u30EB\u30FC\u30EB\u306E\u5909\u66F4\u304C\u5FC5\u8981\u306A\u5834\u5408\u306F\u30E6\u30FC\u30B6\u30FC\u306B\u78BA\u8A8D\u3057\u3066\u304F\u3060\u3055\u3044\uFF09\u3002`);
+  lines.push(``);
+  lines.push(`## Violations`);
+  lines.push(``);
+  failures.forEach((f, idx) => {
+    const rule = ruleMap.get(f.rule.toLowerCase());
+    const tag = f.severity === "warn" ? "[WARN]" : "[ERROR]";
+    lines.push(`### ${idx + 1}. ${tag} ${f.rule}`);
+    lines.push(``);
+    if (rule) {
+      lines.push(`- **\u30B0\u30EB\u30FC\u30D7**: ${rule.group}`);
+      const scope = rule.filePatterns.length > 0 ? rule.filePatterns.join(", ") : "\u5168\u30D5\u30A1\u30A4\u30EB";
+      lines.push(`- **\u9069\u7528\u30B9\u30B3\u30FC\u30D7**: ${scope}`);
+      if (rule.lineNumber) {
+        lines.push(`- **\u30EB\u30FC\u30EB\u5B9A\u7FA9**: rules.md:${rule.lineNumber}`);
+      }
+    }
+    lines.push(`- **\u5909\u66F4\u30D5\u30A1\u30A4\u30EB**: ${staged.files.join(", ")}`);
+    lines.push(``);
+    lines.push(`**\u9055\u53CD\u7406\u7531**:`);
+    lines.push(``);
+    const reason = f.reason.trim() || "(no reason provided)";
+    for (const line of reason.split("\n")) {
+      lines.push(`> ${line}`);
+    }
+    lines.push(``);
+  });
+  return lines.join("\n");
+}
+function formatTimestamp(d) {
+  const pad = (n) => String(n).padStart(2, "0");
+  const y = d.getFullYear();
+  const mo = pad(d.getMonth() + 1);
+  const da = pad(d.getDate());
+  const h = pad(d.getHours());
+  const mi = pad(d.getMinutes());
+  const s = pad(d.getSeconds());
+  return `${y}-${mo}-${da}T${h}-${mi}-${s}`;
+}
+
+// src/cli.ts
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = dirname(__filename);
+function createCli() {
+  const program2 = new Command();
+  program2.name("kanzaki").description("LLM-powered semantic pre-commit linter").version("0.2.0");
+  program2.command("init").description("Create .kanzaki/rules.md rules file").action(async () => {
+    const cwd = process.cwd();
+    const rulesPath = resolve4(cwd, ".kanzaki", "rules.md");
+    const rulesDir = dirname(rulesPath);
+    if (!existsSync5(rulesDir)) {
+      mkdirSync3(rulesDir, { recursive: true });
+    }
+    if (existsSync5(rulesPath)) {
+      console.log(chalk2.yellow("\u26A0 .kanzaki/rules.md already exists, skipping."));
+    } else {
+      const template = loadTemplate();
+      writeFileSync3(rulesPath, template, "utf-8");
+      console.log(chalk2.green("\u2713 Created .kanzaki/rules.md"));
+    }
+    const kanzakiGitignore = resolve4(rulesDir, ".gitignore");
+    if (!existsSync5(kanzakiGitignore)) {
+      writeFileSync3(kanzakiGitignore, "reviews/\n", "utf-8");
+      console.log(chalk2.green("\u2713 Created .kanzaki/.gitignore"));
+    }
+    console.log();
+    console.log(chalk2.dim("Edit .kanzaki/rules.md to customize your review rules."));
+    console.log(chalk2.dim("You can run 'kanzaki check' directly, or set it up with husky/lint-staged."));
+    console.log(chalk2.dim("Run 'kanzaki login' to authenticate."));
+  });
+  program2.command("check").description("Review staged changes against rules").option("-p, --provider <provider>", "LLM provider (openai / anthropic)").option("-m, --model <model>", "Model name").option("-r, --rules <path>", "Path to rules file", ".kanzaki/rules.md").option("--api-key <key>", "API key (prefer KANZAKI_API_KEY env var)").option("--no-block", "Warn only, don't block commit").option("-o, --emit-feedback", "Write feedback markdown (for coding agents) to .kanzaki/reviews/").option("-v, --verbose", "Verbose output").action(async (opts) => {
+    try {
+      if (!hasStagedChanges()) {
+        console.log(chalk2.yellow("No staged changes found. Nothing to review."));
+        process.exit(0);
+      }
+      const config = loadConfig({
+        provider: opts.provider,
+        apiKey: opts.apiKey,
+        model: opts.model,
+        rulesPath: opts.rules,
+        verbose: opts.verbose ?? false,
+        noBlock: opts.noBlock === false
+        // commander の --no-block は block=false にする
+      });
+      if (!existsSync5(config.rulesPath)) {
+        console.error(chalk2.red(`Rules file not found: ${config.rulesPath}`));
+        console.error(chalk2.dim("Run 'kanzaki init' to create one."));
+        process.exit(1);
+      }
+      const { rules, context: rulesContext, errors: parseErrors } = parseRulesFile(config.rulesPath);
+      if (parseErrors && parseErrors.length > 0) {
+        console.error(chalk2.red.bold(`
+\u274C Found ${parseErrors.length} formatting error(s) in ${config.rulesPath}:`));
+        parseErrors.forEach((err) => {
+          console.error(chalk2.yellow(`  Line ${err.line}: `) + err.message);
+        });
+        console.error(chalk2.dim("\nPlease fix these errors before committing."));
+        process.exit(1);
+      }
+      if (rules.length === 0) {
+        console.log(chalk2.yellow("No rules found in rules file. Skipping review."));
+        process.exit(0);
+      }
+      const errorRules = rules.filter((r) => r.severity === "error").length;
+      const warnRules = rules.filter((r) => r.severity === "warn").length;
+      if (config.verbose) {
+        console.log(chalk2.dim(`Provider: ${config.provider} (${config.model})`));
+        console.log(chalk2.dim(`Rules: ${errorRules} errors, ${warnRules} warnings`));
+        if (rulesContext) {
+          console.log(chalk2.dim(`Context: ${rulesContext.length} chars of additional context`));
+        }
+      }
+      const staged = getStagedChanges();
+      const fileContexts = getFileContexts(staged.files);
+      const applicableRules = filterRulesByFiles(rules, staged.files);
+      if (applicableRules.length === 0) {
+        console.log(chalk2.yellow("No applicable rules for changed files. Skipping review."));
+        process.exit(0);
+      }
+      if (config.verbose) {
+        console.log(chalk2.dim(`Files changed: ${staged.files.join(", ")}`));
+        if (applicableRules.length < rules.length) {
+          console.log(chalk2.dim(`Rules filtered: ${applicableRules.length}/${rules.length} applicable`));
+        }
+      }
+      console.log(chalk2.dim("Reviewing changes with LLM..."));
+      const result = await review(config, applicableRules, staged, fileContexts, rulesContext);
+      const { errorCount } = report(result, config.verbose);
+      if (opts.emitFeedback) {
+        const rulesDir = dirname(resolve4(config.rulesPath));
+        const reviewsDir = resolve4(rulesDir, "reviews");
+        const feedbackPath = writeFeedbackFile(result, applicableRules, staged, reviewsDir);
+        if (feedbackPath) {
+          console.log(chalk2.dim(`\u2192 Feedback written to ${feedbackPath}`));
+        }
+      }
+      if (errorCount > 0 && !config.noBlock) {
+        process.exit(1);
+      }
+    } catch (error) {
+      console.error(chalk2.red(`Error: ${error.message}`));
+      process.exit(1);
+    }
+  });
+  const SUPPORTED_PROVIDERS = ["openai", "anthropic"];
+  program2.command("login").description("Authenticate with a supported LLM provider").option("-p, --provider <provider>", `Provider to use (${SUPPORTED_PROVIDERS.join(" / ")})`).option("--use-chatgpt", "Log in with ChatGPT Plus/Pro subscription (OAuth)").option("--use-claude", "Use the local Claude CLI as a subprocess").action(async (opts) => {
+    if (opts.useChatgpt) {
+      console.log(chalk2.dim("Starting OAuth Authorization Code Flow..."));
+      try {
+        const token = await loginWithOAuthPKCE();
+        const expiresAt = new Date(Date.now() + token.expires_in * 1e3).toISOString();
+        saveCredentials({
+          provider: "openai",
+          apiKey: "",
+          oauthToken: token.access_token,
+          refreshToken: token.refresh_token,
+          expiresAt
+        });
+        console.log(chalk2.green("\n\u2713 Authenticated via OAuth"));
+      } catch (error) {
+        console.error(chalk2.red(`OAuth failed: ${error.message}`));
+        console.error(chalk2.dim("Try 'kanzaki login' with an API key instead."));
+        process.exit(1);
+      }
+    } else if (opts.useClaude) {
+      console.log(chalk2.dim("Checking local Claude CLI installation..."));
+      try {
+        const version = execSync2("claude --version", { encoding: "utf-8", stdio: ["ignore", "pipe", "pipe"] }).trim();
+        console.log(chalk2.dim(`Found: ${version}`));
+      } catch {
+        console.error(chalk2.red("Claude CLI not found."));
+        console.error(chalk2.dim("Install it from https://docs.claude.com/en/docs/claude-code and run 'claude login' first."));
+        process.exit(1);
+      }
+      saveCredentials({
+        provider: "anthropic",
+        apiKey: "",
+        useClaudeCli: true
+      });
+      console.log(chalk2.green("\n\u2713 Configured to use local Claude CLI"));
+      console.log(chalk2.dim("Kanzaki will invoke 'claude -p' for reviews, using your existing Claude CLI session."));
+      console.log(chalk2.dim("Credentials stored in ~/.config/kanzaki/credentials.json"));
+    } else {
+      if (!opts.provider) {
+        console.error(chalk2.red("Authentication method is required."));
+        console.error(chalk2.dim("Use one of:"));
+        console.error(chalk2.dim(`  kanzaki login --provider <${SUPPORTED_PROVIDERS.join(" | ")}>   (API key)`));
+        console.error(chalk2.dim("  kanzaki login --use-chatgpt                         (ChatGPT OAuth)"));
+        console.error(chalk2.dim("  kanzaki login --use-claude                          (Claude CLI subprocess)"));
+        process.exit(1);
+      }
+      if (!SUPPORTED_PROVIDERS.includes(opts.provider)) {
+        console.error(chalk2.red(`Unknown provider: ${opts.provider}`));
+        console.error(chalk2.dim(`Supported providers: ${SUPPORTED_PROVIDERS.join(", ")}`));
+        process.exit(1);
+      }
+      const provider = opts.provider;
+      const label = provider === "openai" ? "OpenAI" : "Anthropic";
+      const key = await promptSecret(`Enter your ${label} API key: `);
+      if (!key) {
+        console.error(chalk2.red("No API key provided."));
+        process.exit(1);
+      }
+      saveCredentials({ provider, apiKey: key });
+      console.log(chalk2.green(`\u2713 Saved ${provider} credentials`));
+      console.log(chalk2.dim("Credentials stored in ~/.config/kanzaki/credentials.json"));
+    }
+  });
+  program2.command("logout").description("Remove saved credentials").action(() => {
+    clearCredentials();
+    console.log(chalk2.green("\u2713 Credentials removed"));
+  });
+  program2.command("status").description("Show authentication status").action(() => {
+    const creds = loadCredentials();
+    if (!creds || !creds.apiKey && !creds.oauthToken && !creds.useClaudeCli) {
+      console.log(chalk2.yellow("Not authenticated."));
+      console.log(chalk2.dim("Run 'kanzaki login' to authenticate."));
+      return;
+    }
+    console.log(chalk2.bold("Kanzaki Status"));
+    console.log(`  Provider: ${chalk2.cyan(creds.provider)}`);
+    if (creds.useClaudeCli) {
+      console.log(`  Auth: ${chalk2.cyan("Claude CLI subprocess")} ${chalk2.green("(active)")}`);
+    } else if (creds.oauthToken) {
+      const expired = creds.expiresAt && new Date(creds.expiresAt) < /* @__PURE__ */ new Date();
+      console.log(`  Auth: ${chalk2.cyan("OAuth")}${expired ? chalk2.red(" (expired)") : chalk2.green(" (active)")}`);
+    } else {
+      const masked = creds.apiKey.slice(0, 7) + "..." + creds.apiKey.slice(-4);
+      console.log(`  Auth: ${chalk2.cyan("API Key")} (${masked})`);
+    }
+  });
+  return program2;
+}
+function loadTemplate() {
+  const templatePath = resolve4(__dirname, "..", "templates", "rules.md");
+  if (existsSync5(templatePath)) {
+    return readFileSync4(templatePath, "utf-8");
+  }
+  return `# Kanzaki \u30EC\u30D3\u30E5\u30FC\u30EB\u30FC\u30EB
+
+## \u54C1\u8CEA
+- [ ] !error \u5909\u66F4\u5185\u5BB9\u304C\u30D7\u30ED\u30B8\u30A7\u30AF\u30C8\u306E\u65E2\u5B58\u306E\u30B9\u30BF\u30A4\u30EB\u3084\u898F\u7D04\u3068\u4E00\u8CAB\u3057\u3066\u3044\u308B\u3053\u3068
+- [ ] !error \u30D7\u30EC\u30FC\u30B9\u30DB\u30EB\u30C0\u30FC\u3084TODO\u304C\u6B8B\u3063\u3066\u3044\u306A\u3044\u3053\u3068
+- [ ] !warn \u5185\u5BB9\u304C\u660E\u78BA\u30FB\u7C21\u6F54\u3067\u3001\u4E0D\u8981\u306A\u7E70\u308A\u8FD4\u3057\u304C\u306A\u3044\u3053\u3068
+
+## \u6B63\u78BA\u6027
+- [ ] !error \u4E8B\u5B9F\u8AA4\u8A8D\u3084\u8AA4\u89E3\u3092\u62DB\u304F\u60C5\u5831\u304C\u542B\u307E\u308C\u3066\u3044\u306A\u3044\u3053\u3068
+- [ ] !warn \u9069\u5207\u306A\u7B87\u6240\u306B\u51FA\u5178\u30FB\u53C2\u8003\u6587\u732E\u304C\u8A18\u8F09\u3055\u308C\u3066\u3044\u308B\u3053\u3068
+
+## \u30BB\u30AD\u30E5\u30EA\u30C6\u30A3 (*.ts, *.js, *.py)
+- [ ] !error \u30CF\u30FC\u30C9\u30B3\u30FC\u30C9\u3055\u308C\u305F\u30B7\u30FC\u30AF\u30EC\u30C3\u30C8\u30FBAPI\u30AD\u30FC\u30FB\u30D1\u30B9\u30EF\u30FC\u30C9\u304C\u542B\u307E\u308C\u3066\u3044\u306A\u3044\u3053\u3068
+`;
+}
+function promptSecret(prompt) {
+  return new Promise((resolve5) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    process.stdout.write(prompt);
+    const stdin = process.stdin;
+    const wasRaw = stdin.isRaw;
+    if (stdin.isTTY && stdin.setRawMode) {
+      stdin.setRawMode(true);
+    }
+    let input = "";
+    const onData = (char) => {
+      const c = char.toString();
+      if (c === "\n" || c === "\r") {
+        stdin.removeListener("data", onData);
+        if (stdin.isTTY && stdin.setRawMode) {
+          stdin.setRawMode(wasRaw ?? false);
+        }
+        process.stdout.write("\n");
+        rl.close();
+        resolve5(input);
+      } else if (c === "") {
+        process.exit(1);
+      } else if (c === "\x7F" || c === "\b") {
+        input = input.slice(0, -1);
+      } else {
+        input += c;
+        process.stdout.write("*");
+      }
+    };
+    stdin.on("data", onData);
+  });
+}
+
+// src/bin.ts
+var program = createCli();
+program.parse();
+//# sourceMappingURL=bin.js.map