pika-review 2.1.0 → 2.3.0

package/README.md

@@ -1,4 +1,4 @@
-# Pika Review 🦊
+# Pika Review 🦊 [![Pika Sentinel Grade](badge.svg)](https://github.com/HackX-IN/pika-review)
 
 ### Enterprise-grade AI Architectural Sentinel & Compliance Engine
 
@@ -11,12 +11,15 @@ Pika Review is a high-performance CLI tool designed to perform surgical code rev
 ## 🚀 Key Features
 
 - **🧠 Architecture Rules Engine**: Enforce project-specific standards via `.pika-rules.md`.
+- **🦙 Native Local Ollama Support**: Run 100% private, free, offline scans using local LLMs (e.g. Qwen, Llama).
+- **🎛️ Local Model Selector**: Interactively choose and configure local models from the command line.
+- **🛡️ Git Commit Safeguard Hook**: Prevent pushing high-severity compliance debt and vulnerabilities automatically.
 - **📊 Health Dashboard**: Track architectural health trends over time with `pika-review stats`.
 - **🎨 Premium Interactive Reports**: Immersive, dark-mode HTML reports for deep triage.
 - **🔍 Smart Context Scanning**: Uses `-U10` context windows for higher AI reasoning accuracy.
 - **🛡️ "Pika-Ignore" support**: Suppress specific lines using `// pika-ignore` comments.
 - **⚡ Parallel Orchestration**: Scans multiple files concurrently with `p-limit`.
-- **🌍 Provider Agnostic**: Works with OpenAI, Claude, Grok, or any OpenAI-compatible endpoint.
+- **🌍 Provider Agnostic**: Works with OpenAI, Claude, Grok, local Ollama, or any OpenAI-compatible endpoint.
 
 ---
 
@@ -80,13 +83,57 @@ pika-review stats
 
 ## 🔍 Usage
 
-| Command                 | Description                           |
-| :---------------------- | :------------------------------------ |
-| `pika-review scan`      | Scan staged git changes (Default)     |
-| `pika-review scan -i`   | Interactive file selection mode       |
-| `pika-review view`      | Open the latest interactive report    |
-| `pika-review stats`     | View architectural health dashboard   |
-| `pika-review scan --ci` | Fail pipeline on Critical/High issues |
+| Command                 | Description                                                  |
+| :---------------------- | :----------------------------------------------------------- |
+| `pika-review scan`      | Scan staged git changes (Default)                            |
+| `pika-review scan -i`   | Interactive file selection mode                              |
+| `pika-review view`      | Open the latest interactive report                           |
+| `pika-review stats`     | View architectural health trends and scan dashboard          |
+| `pika-review models`    | Interactively select and configure local Ollama models       |
+| `pika-review hook <act>`| Install (`install`) or uninstall (`uninstall`) Git safeguards |
+| `pika-review rules -g`  | Auto-generate architectural `.pika-rules.md` guidelines       |
+| `pika-review scan --ci` | Fail pipeline on Critical/High issues                        |
+
+---
+
+## 🦙 Local Ollama & Offline Setup
+
+Pika Review fully supports local, 100% private, offline code reviews via [Ollama](https://ollama.com).
+
+### 1. Configure Ollama Provider
+Initialize your configuration:
+```bash
+pika-review init
+```
+Open `~/.pika-review.yaml` and configure the Ollama provider:
+```yaml
+ai:
+  provider: "ollama"
+  model: "qwen2.5-coder:7b" # Or your pulled model
+  baseURL: "http://localhost:11434/v1"
+```
+
+### 2. Interactive Local Setup
+To avoid editing files manually, you can manage everything directly from the command line:
+
+```bash
+# Discover local pulled models and switch active model instantly
+pika-review models
+
+# Automatically bootstrap customized architectural rules for your tech stack
+pika-review rules --generate
+
+# Register git safeguard hooks to run scans automatically before commits
+pika-review hook install
+```
+
+---
+
+## 🤝 Contributing
+
+We welcome contributions from the community to help make Pika Review the ultimate architectural code reviewer! 
+
+Please read our **[Contributing Guide](CONTRIBUTING.md)** for details on how to set up local development, run compiler checks, write custom CLI commands, and submit high-quality Pull Requests.
 
 ---
 

package/dist/cmd/autofix.js

@@ -0,0 +1,61 @@
+import fs from "fs";
+import chalk from "chalk";
+import { execSync } from "child_process";
+/**
+ * Extracts the first markdown fenced code block from a recommendation string.
+ */
+export function extractCodeBlock(markdown) {
+    // Regex matches triple backtick block with optional language identifier
+    const match = markdown.match(/```[a-zA-Z]*\n([\s\S]*?)\n```/);
+    return match ? match[1] : null;
+}
+/**
+ * Patches a target file in-place with an AI code block at a specific line number.
+ * Preserves the original indentation of the line being replaced.
+ */
+export function applyAutoFix(filePath, lineNum, recommendation) {
+    try {
+        if (!fs.existsSync(filePath)) {
+            console.log(`  ${chalk.red("✖")} Target file not found: ${filePath}`);
+            return false;
+        }
+        const code = extractCodeBlock(recommendation);
+        if (!code) {
+            console.log(`  ${chalk.red("✖")} No valid code block found in recommendation to apply.`);
+            return false;
+        }
+        const content = fs.readFileSync(filePath, "utf-8");
+        const lines = content.split(/\r?\n/);
+        if (lineNum !== undefined && lineNum > 0 && lineNum <= lines.length) {
+            // Find indentation of the original line to preserve nesting structure
+            const indent = lines[lineNum - 1].match(/^\s*/)?.[0] || "";
+            const indentedCode = code.split("\n").map(l => indent + l).join("\n");
+            lines[lineNum - 1] = indentedCode;
+            fs.writeFileSync(filePath, lines.join("\n"), "utf-8");
+            console.log(`\n  ${chalk.green("✓")} Clean code applied to ${chalk.bold(filePath)} at line ${lineNum}.`);
+            // Render Git Diff for immediate visual confirmation
+            try {
+                console.log(`\n  ${chalk.cyan.bold("◆  Git Diff Confirmation:")}`);
+                const diff = execSync(`git diff --color "${filePath}"`, { encoding: "utf-8" });
+                if (diff.trim()) {
+                    console.log(diff);
+                }
+                else {
+                    console.log(`     ${chalk.dim("Lines matched exactly; no raw text diff produced.")}`);
+                }
+            }
+            catch (diffErr) {
+                // Fail silently if git is not initialized or diff fails
+            }
+            return true;
+        }
+        else {
+            console.log(`  ${chalk.red("✖")} Target line number is out of bounds or undefined.`);
+            return false;
+        }
+    }
+    catch (e) {
+        console.log(`  ${chalk.red("✖")} Failed to apply auto-fix: ${e.message}`);
+        return false;
+    }
+}

package/dist/cmd/chat.js

@@ -0,0 +1,87 @@
+import fs from "fs";
+import chalk from "chalk";
+import prompts from "prompts";
+import OpenAI from "openai";
+import { getConfig } from "../utils/config.js";
+/**
+ * CLI Command: discuss [file]
+ * Launches an interactive Socratic chat session inside the console focusing on design context.
+ */
+export async function discussAction(filePath) {
+    if (!fs.existsSync(filePath)) {
+        console.log(`  ${chalk.red("✖")} Target file not found: ${filePath}`);
+        return;
+    }
+    const config = getConfig();
+    const isOllama = config.ai.provider === "ollama";
+    const isCloudflare = config.ai.provider === "cloudflare";
+    const baseURL = config.ai.baseURL && config.ai.baseURL.trim()
+        ? config.ai.baseURL
+        : (isOllama
+            ? "http://localhost:11434/v1"
+            : (isCloudflare
+                ? `https://api.cloudflare.com/client/v4/accounts/${config.ai.accountId}/ai/v1`
+                : "https://api.openai.com/v1"));
+    const openai = new OpenAI({
+        apiKey: config.ai.apiKey || "ollama",
+        baseURL,
+    });
+    const fileContent = fs.readFileSync(filePath, "utf-8");
+    // Load custom architecture standards rules if they exist
+    let complianceSection = "";
+    try {
+        const rulesPath = ".pika-rules.md";
+        if (fs.existsSync(rulesPath)) {
+            complianceSection = `\nCustom Rules:\n${fs.readFileSync(rulesPath, "utf-8")}`;
+        }
+    }
+    catch (e) { }
+    const messages = [
+        {
+            role: "system",
+            content: `You are an Elite Senior Full-Stack Architect and Security Mentor.
+Your task is to have an interactive Socratic discussion with the developer regarding the provided file.
+Help them brainstorm alternative patterns, explain the reasoning behind quality benchmarks, and walk them through refactoring steps.
+
+Target File Path: ${filePath}
+File Content:
+\`\`\`
+${fileContent}
+\`\`\`
+${complianceSection}`
+        }
+    ];
+    console.log(`\n  ${chalk.cyan.bold("◆  Socratic Chat Started")}`);
+    console.log(`     Discussing: ${chalk.bold(filePath)}`);
+    console.log(`     Type ${chalk.yellow("exit")} or ${chalk.yellow("quit")} to end the session.\n`);
+    while (true) {
+        const userInput = await prompts({
+            type: "text",
+            name: "message",
+            message: `${chalk.green("💬 You:")}`,
+        });
+        if (!userInput.message || userInput.message.trim() === "")
+            continue;
+        const trimmed = userInput.message.trim();
+        if (trimmed.toLowerCase() === "exit" || trimmed.toLowerCase() === "quit") {
+            console.log(`\n  ${chalk.cyan("→")} Discuss session finished. Happy coding!\n`);
+            break;
+        }
+        messages.push({ role: "user", content: trimmed });
+        process.stdout.write(`\n  ${chalk.cyan.bold("◆  Pika Sentinel:")}\n     `);
+        try {
+            const response = await openai.chat.completions.create({
+                model: config.ai.model,
+                messages,
+                temperature: 0.2,
+            });
+            const reply = response.choices[0]?.message?.content || "";
+            console.log(reply.split("\n").join("\n     "));
+            console.log();
+            messages.push({ role: "assistant", content: reply });
+        }
+        catch (e) {
+            console.log(`${chalk.red("✖")} Error communicating with AI: ${e.message}\n`);
+        }
+    }
+}

package/dist/cmd/github.js

@@ -0,0 +1,79 @@
+import fs from "fs";
+import chalk from "chalk";
+/**
+ * Automates Pull Request inline code-reviews by posting reviews directly to GitHub.
+ * Utilizes lightweight native fetch calls to keep dependencies at zero.
+ */
+export async function postGitHubPRComments(findings) {
+    const token = process.env.GITHUB_TOKEN;
+    const eventPath = process.env.GITHUB_EVENT_PATH;
+    if (!token || !eventPath) {
+        return false;
+    }
+    try {
+        if (!fs.existsSync(eventPath)) {
+            console.log(`  ${chalk.red("✖")} GITHUB_EVENT_PATH file not found.`);
+            return false;
+        }
+        const event = JSON.parse(fs.readFileSync(eventPath, "utf-8"));
+        const prNumber = event.pull_request?.number;
+        const repoFullName = event.repository?.full_name; // e.g. "owner/repo"
+        if (!prNumber || !repoFullName) {
+            console.log(`  ${chalk.red("✖")} Missing PR number or Repository Name in GitHub Event.`);
+            return false;
+        }
+        // Get current head commit SHA required for target PR diff annotations
+        const commitSha = event.pull_request?.head?.sha;
+        if (!commitSha) {
+            console.log(`  ${chalk.red("✖")} Head Commit SHA is missing.`);
+            return false;
+        }
+        console.log(`\n  ${chalk.cyan("→")} Syncing ${findings.length} findings with GitHub PR #${prNumber}...`);
+        for (const f of findings) {
+            const fileName = f.fileName;
+            for (const r of f.reviews) {
+                if (!r.line)
+                    continue;
+                const body = `### 🚨 Pika Sentinel: ${r.severity} Finding
+**Finding:** ${r.finding}
+**Impact:** ${r.impact}
+
+**Recommendation:**
+\`\`\`
+${r.recommendation}
+\`\`\`
+`;
+                const url = `https://api.github.com/repos/${repoFullName}/pulls/${prNumber}/comments`;
+                const payload = {
+                    body,
+                    commit_id: commitSha,
+                    path: fileName,
+                    side: "RIGHT",
+                    line: r.line,
+                };
+                const response = await fetch(url, {
+                    method: "POST",
+                    headers: {
+                        "Authorization": `Bearer ${token}`,
+                        "Accept": "application/vnd.github.v3+json",
+                        "Content-Type": "application/json",
+                        "User-Agent": "Pika-Sentinel-Reviewer"
+                    },
+                    body: JSON.stringify(payload),
+                });
+                if (!response.ok) {
+                    const errMsg = await response.text();
+                    console.log(`     ${chalk.red("✖")} Failed to post comment on ${fileName}:${r.line}: ${errMsg}`);
+                }
+                else {
+                    console.log(`     ${chalk.green("✓")} Posted inline review on ${fileName}:${r.line}`);
+                }
+            }
+        }
+        return true;
+    }
+    catch (e) {
+        console.log(`  ${chalk.red("✖")} Failed to post comments to GitHub PR: ${e.message}`);
+        return false;
+    }
+}

package/dist/cmd/hook.js

@@ -0,0 +1,85 @@
+import fs from "fs";
+import path from "path";
+import chalk from "chalk";
+import { logger } from "../utils/logger.js";
+/**
+ * CLI Command Action: hook [action]
+ * Manages the Git pre-commit hook installation/removal.
+ */
+export async function hookAction(action) {
+    const gitPath = path.join(process.cwd(), ".git");
+    if (!fs.existsSync(gitPath)) {
+        logger.error("Not a Git repository.");
+        logger.dim("Pika Review Git hooks can only be installed in the root of a Git repository.");
+        return;
+    }
+    const hooksPath = path.join(gitPath, "hooks");
+    const hookFile = path.join(hooksPath, "pre-commit");
+    // Ensure hooks directory exists
+    if (!fs.existsSync(hooksPath)) {
+        fs.mkdirSync(hooksPath, { recursive: true });
+    }
+    const HOOK_SCRIPT = `#!/bin/sh
+# Pika Review - Architectural Sentinel Git Safeguard Hook
+echo "🦊 Running local architectural compliance checks..."
+pika-review scan --ci
+
+EXIT_CODE=$?
+if [ $EXIT_CODE -ne 0 ]; then
+  echo "❌ [Pika Review] Commit rejected due to high-severity compliance anomalies."
+  exit $EXIT_CODE
+fi
+
+exit 0
+`;
+    if (action === "install") {
+        let backupCreated = false;
+        if (fs.existsSync(hookFile)) {
+            const content = fs.readFileSync(hookFile, "utf-8");
+            if (content.includes("Pika Review")) {
+                logger.info("Pika Review hook is already installed!");
+                return;
+            }
+            // Create backup of existing hook
+            const backupPath = `${hookFile}.bak`;
+            fs.writeFileSync(backupPath, content);
+            backupCreated = true;
+            logger.info(`Existing hook backed up to ${chalk.cyan("pre-commit.bak")}`);
+        }
+        try {
+            fs.writeFileSync(hookFile, HOOK_SCRIPT, { mode: 0o755 });
+            logger.success("Git pre-commit hook installed successfully!");
+            logger.info(`Path: ${chalk.dim(hookFile)}`);
+            logger.dim("Pika Review will now scan your staged files automatically before every commit.");
+        }
+        catch (e) {
+            logger.error(`Failed to install Git hook: ${e.message}`);
+        }
+    }
+    else if (action === "uninstall") {
+        if (!fs.existsSync(hookFile)) {
+            logger.warn("No pre-commit hook found to uninstall.");
+            return;
+        }
+        const content = fs.readFileSync(hookFile, "utf-8");
+        if (!content.includes("Pika Review")) {
+            logger.warn("The existing pre-commit hook was not installed by Pika Review. Leaving it untouched.");
+            return;
+        }
+        try {
+            fs.unlinkSync(hookFile);
+            logger.success("Pika Review Git pre-commit hook uninstalled successfully.");
+            // Restore backup if it exists
+            const backupPath = `${hookFile}.bak`;
+            if (fs.existsSync(backupPath)) {
+                fs.renameSync(backupPath, hookFile);
+                // Make sure it remains executable
+                fs.chmodSync(hookFile, 0o755);
+                logger.success("Restored previous pre-commit hook from backup!");
+            }
+        }
+        catch (e) {
+            logger.error(`Failed to uninstall Git hook: ${e.message}`);
+        }
+    }
+}

package/dist/cmd/models.js

@@ -0,0 +1,68 @@
+import prompts from "prompts";
+import chalk from "chalk";
+import { getConfig, saveConfig } from "../utils/config.js";
+import { logger } from "../utils/logger.js";
+/**
+ * CLI Command Action: models
+ * Queries local Ollama daemon for available models and updates active configuration.
+ */
+export async function modelsAction() {
+    const config = getConfig();
+    // Extract base host from configuration baseURL or fallback to localhost
+    let host = "http://localhost:11434";
+    if (config.ai.baseURL) {
+        try {
+            const url = new URL(config.ai.baseURL);
+            host = `${url.protocol}//${url.host}`;
+        }
+        catch (e) { }
+    }
+    logger.info(`Connecting to Ollama daemon at ${chalk.cyan(host)}...`);
+    try {
+        const res = await fetch(`${host}/api/tags`);
+        if (!res.ok) {
+            throw new Error(`Server returned HTTP ${res.status}`);
+        }
+        const data = (await res.json());
+        if (!data.models || data.models.length === 0) {
+            logger.warn(`No models found inside your local Ollama instance.`);
+            logger.info(`Try pulling a model first using: ${chalk.yellow("ollama pull llama3")}`);
+            return;
+        }
+        const choices = data.models.map((m) => {
+            const sizeGB = m.size ? `${(m.size / (1024 * 1024 * 1024)).toFixed(2)} GB` : "Unknown size";
+            const paramSize = m.details?.parameter_size ? ` [${m.details.parameter_size}]` : "";
+            return {
+                title: `${chalk.bold(m.name)} ${chalk.dim(`(${sizeGB}${paramSize})`)}`,
+                value: m.name,
+            };
+        });
+        const response = await prompts({
+            type: "select",
+            name: "model",
+            message: "Select your active local Ollama model:",
+            choices,
+            initial: 0,
+        });
+        if (response.model) {
+            config.ai.provider = "ollama";
+            config.ai.model = response.model;
+            // Auto-set standard baseURL if empty or not set to localhost
+            if (!config.ai.baseURL || config.ai.baseURL.includes("cloudflare")) {
+                config.ai.baseURL = "http://localhost:11434/v1";
+            }
+            saveConfig(config);
+            logger.success(`Configuration updated successfully!`);
+            logger.info(`Active Model:   ${chalk.green(response.model)}`);
+            logger.info(`AI Provider:    ${chalk.cyan("ollama")}`);
+            logger.info(`API Base URL:   ${chalk.cyan(config.ai.baseURL)}`);
+        }
+    }
+    catch (error) {
+        logger.error(`Could not connect to Ollama daemon.`);
+        console.log(chalk.dim(`\n💡 To solve this, make sure:`));
+        console.log(` 1. Ollama is installed on your machine (https://ollama.com).`);
+        console.log(` 2. The daemon is running (${chalk.yellow("ollama serve")} or desktop application).`);
+        console.log(` 3. Your config baseURL is pointing to your active daemon (current: ${chalk.red(host)}).\n`);
+    }
+}

package/dist/cmd/rules.js

@@ -0,0 +1,131 @@
+import fs from "fs";
+import path from "path";
+import prompts from "prompts";
+import chalk from "chalk";
+import OpenAI from "openai";
+import { getConfig } from "../utils/config.js";
+import { listProjectFiles } from "../core/scanner.js";
+import { logger } from "../utils/logger.js";
+/**
+ * CLI Command Action: rules generate
+ * Uses the configured AI provider to bootstrap architectural rules tailored to the current codebase.
+ */
+export async function rulesAction() {
+    const config = getConfig();
+    const isOllama = config.ai.provider === "ollama";
+    if (!isOllama && (!config.ai.apiKey || !config.ai.accountId)) {
+        logger.error("Missing AI credentials in ~/.pika-review.yaml.");
+        logger.info("Run 'pika-review init' to initialize config or set provider to 'ollama' for offline mode.");
+        return;
+    }
+    const rulesPath = path.join(process.cwd(), ".pika-rules.md");
+    if (fs.existsSync(rulesPath)) {
+        const overwrite = await prompts({
+            type: "confirm",
+            name: "confirm",
+            message: "An existing .pika-rules.md already exists. Do you want to overwrite it?",
+            initial: false,
+        });
+        if (!overwrite.confirm) {
+            logger.info("Operation cancelled.");
+            return;
+        }
+    }
+    else {
+        const confirm = await prompts({
+            type: "confirm",
+            name: "confirm",
+            message: "Generate a custom, AI-crafted .pika-rules.md architectural guidelines guide for this codebase?",
+            initial: true,
+        });
+        if (!confirm.confirm) {
+            logger.info("Operation cancelled.");
+            return;
+        }
+    }
+    logger.info("Analyzing codebase structure and dependencies...");
+    // 1. Gather package.json context
+    let projectTechStack = "";
+    const frameworkClassifications = [];
+    try {
+        const packageJsonPath = path.join(process.cwd(), "package.json");
+        if (fs.existsSync(packageJsonPath)) {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+            const allDeps = { ...(packageJson.dependencies || {}), ...(packageJson.devDependencies || {}) };
+            if (allDeps["next"])
+                frameworkClassifications.push("Next.js Framework");
+            if (allDeps["react"])
+                frameworkClassifications.push("React UI Library");
+            if (allDeps["express"])
+                frameworkClassifications.push("Express.js Server");
+            if (allDeps["tailwindcss"])
+                frameworkClassifications.push("Tailwind CSS v4 styling");
+            if (allDeps["typescript"])
+                frameworkClassifications.push("TypeScript Static Typings");
+            if (allDeps["bun-types"] || allDeps["@types/bun"])
+                frameworkClassifications.push("Bun High-Performance Runtime");
+            const deps = Object.keys(packageJson.dependencies || {}).join(", ");
+            const devDeps = Object.keys(packageJson.devDependencies || {}).join(", ");
+            projectTechStack += `Package Name: ${packageJson.name || "unknown"}\nDependencies: ${deps || "none"}\nDevDependencies: ${devDeps || "none"}\n`;
+        }
+    }
+    catch (e) { }
+    if (frameworkClassifications.length > 0) {
+        projectTechStack += `Detected Frameworks & Archetypes: ${frameworkClassifications.join(", ")}\n`;
+    }
+    // 2. Gather file layout context
+    const files = listProjectFiles();
+    const fileSummary = files.slice(0, 30).map(f => ` - ${f}`).join("\n");
+    const projectStructure = `Detected files (subset):\n${fileSummary}\nTotal files discovered: ${files.length}\n`;
+    logger.info(`Synthesizing tailored rules using AI model (${chalk.green(config.ai.model)})...`);
+    const prompt = `You are an Elite Senior Software Architect and Compliance Officer.
+Your task is to write a highly detailed, professional, and practical architectural rules file called ".pika-rules.md" for a project with the following tech stack and structure:
+
+<project_tech_stack>
+${projectTechStack || "Generic web/software codebase"}
+</project_tech_stack>
+
+<project_structure>
+${projectStructure}
+</project_structure>
+
+Instructions:
+- Write the output in clean, professional Markdown format.
+- Establish 5 to 8 strict, concrete, actionable architectural rules tailored to the libraries, patterns, and folder layout of this specific project (e.g. naming conventions, folder segregation, API patterns, state management, security).
+- Provide a brief justification for each rule.
+- Do NOT output any preamble, greeting, markdown backticks wrapper, or postscript.
+- Start directly with "# Pika Architectural Rules" and start rules lists immediately.`;
+    const baseURL = config.ai.baseURL && config.ai.baseURL.trim()
+        ? config.ai.baseURL
+        : (isOllama
+            ? "http://localhost:11434/v1"
+            : `https://api.cloudflare.com/client/v4/accounts/${config.ai.accountId}/ai/v1`);
+    const openai = new OpenAI({
+        apiKey: config.ai.apiKey || "ollama",
+        baseURL,
+    });
+    try {
+        const response = await openai.chat.completions.create({
+            model: config.ai.model,
+            messages: [{ role: "user", content: prompt }],
+            temperature: 0.3,
+            max_tokens: 1500,
+        });
+        let rawMarkdown = response.choices[0]?.message?.content || "";
+        // Clean code block ticks if LLM ignored instructions
+        rawMarkdown = rawMarkdown
+            .replace(/```markdown/g, "")
+            .replace(/```/g, "")
+            .trim();
+        if (!rawMarkdown.startsWith("#")) {
+            rawMarkdown = `# Pika Architectural Rules\n\n${rawMarkdown}`;
+        }
+        fs.writeFileSync(rulesPath, rawMarkdown, "utf-8");
+        logger.success(".pika-rules.md generated successfully!");
+        logger.info(`Location: ${chalk.dim(rulesPath)}`);
+        logger.dim("The local Pika Review engine will now enforce these rules during future scans!");
+    }
+    catch (error) {
+        logger.error(`Failed to generate rules: ${error.message}`);
+    }
+}