pika-review 2.2.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
 

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/rules.js

@@ -46,16 +46,33 @@ export async function rulesAction() {
     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");

package/dist/cmd/scan.js

@@ -3,6 +3,8 @@ import chalk from "chalk";
 import { execSync } from "child_process";
 import { runScan, getDiffFiles, listProjectFiles } from "../core/scanner.js";
 import { logger } from "../utils/logger.js";
+import { applyAutoFix } from "./autofix.js";
+import { postGitHubPRComments } from "./github.js";
 /**
  * CLI Command: scan
  * Executes the scanning logic and handles user interaction for reports.
@@ -34,6 +36,10 @@ export async function scanAction(files, options) {
         }
     }
     const { markdownReports, htmlReport, findings } = await runScan(target, isCI, targets);
+    // If in CI and GITHUB_TOKEN is present, automatically post reviews
+    if (isCI && process.env.GITHUB_TOKEN && process.env.GITHUB_EVENT_PATH) {
+        await postGitHubPRComments(findings);
+    }
     if (!markdownReports || markdownReports.length === 0) {
         if (!isCI) {
             console.log(`\n  ${chalk.green("✓")}  ${chalk.bold("Scan complete. No architectural anomalies or security risks detected.")}`);
@@ -84,6 +90,7 @@ export async function scanAction(files, options) {
             message: "Choose post-scan action:",
             choices: [
                 { title: "✨ Open Interactive HTML Dashboard (Recommended)", value: "html" },
+                { title: "🔧 Launch Interactive Auto-Fixer", value: "autofix" },
                 { title: "📂 List generated Markdown file paths", value: "markdown" },
                 { title: "🛑 Exit and start refactoring", value: "exit" },
             ],
@@ -100,6 +107,34 @@ export async function scanAction(files, options) {
                 console.log(`     ${chalk.dim(`Manually open: file://${htmlReport}`)}`);
             }
         }
+        else if (response.action === "autofix") {
+            const fixableIssues = [];
+            findings.forEach((f) => {
+                f.reviews.forEach((r) => {
+                    if (r.line) {
+                        fixableIssues.push({
+                            title: `[${r.severity}] ${f.fileName}:${r.line} - ${r.finding.substring(0, 45)}...`,
+                            value: { filePath: f.fileName, review: r }
+                        });
+                    }
+                });
+            });
+            if (fixableIssues.length === 0) {
+                console.log(`\n  ${chalk.yellow("⚠")} No fixable issues with valid line numbers found.`);
+            }
+            else {
+                const issueSelect = await prompts({
+                    type: "select",
+                    name: "issue",
+                    message: "Select an architectural issue to auto-patch:",
+                    choices: fixableIssues,
+                });
+                if (issueSelect.issue) {
+                    const { filePath, review } = issueSelect.issue;
+                    applyAutoFix(filePath, review.line, review.recommendation);
+                }
+            }
+        }
         else if (response.action === "markdown") {
             console.log(`\n  ${chalk.bold("Generated Markdown Artifacts:")}`);
             markdownReports.forEach((r) => {

package/dist/core/ai.js

@@ -112,10 +112,10 @@ ${fs.readFileSync(rulesPath, "utf-8")}
 
 <task>
   Identify high-impact issues related to:
-  1. SYSTEM COMPROMISE: Security vulnerabilities, insecure data handling.
-  2. COMPUTATIONAL INEFFICIENCY: Algorithmic bottlenecks, memory leaks.
-  3. ARCHITECTURAL DEBT: Logic flaws, redundant complexity.
-  4. UI/UX ANOMALIES: Layout shifts, accessibility (a11y) violations, and CSS performance issues.
+  1. SYSTEM COMPROMISE & SECURITY: Vulnerabilities (OWASP Top 10 API/Web standard compliance), hardcoded credentials, private keys, API secrets, or insecure default configurations.
+  2. COMPUTATIONAL INEFFICIENCY: Algorithmic bottlenecks, memory leaks, nested processing.
+  3. ARCHITECTURAL DEBT: Logic flaws, breaking structures, redundant modular complexity.
+  4. UI/UX ANOMALIES: Layout shifts, accessibility (a11y) standard violations, and inefficient CSS paths.
 </task>
 
 <instructions>

package/dist/core/cache.js

@@ -0,0 +1,55 @@
+import fs from "fs";
+import path from "path";
+import crypto from "crypto";
+const CACHE_FILE = path.join(".pika-reports", "cache.json");
+/**
+ * Computes a unique SHA-256 hash representing the current files scan state and custom rules.
+ */
+export function computeScanHash(files, rulesContent) {
+    const hash = crypto.createHash("sha256");
+    // Sort files by path to ensure consistent hash ordering
+    const sortedFiles = [...files].sort((a, b) => a.filePath.localeCompare(b.filePath));
+    for (const file of sortedFiles) {
+        hash.update(`file:${file.filePath}\ncontent:${file.content}\n`);
+    }
+    hash.update(`rules:${rulesContent}`);
+    return hash.digest("hex");
+}
+/**
+ * Retrieves the cached scan finding results if it exists.
+ */
+export function getCache(hash) {
+    try {
+        if (!fs.existsSync(CACHE_FILE))
+            return null;
+        const data = fs.readFileSync(CACHE_FILE, "utf-8");
+        const json = JSON.parse(data);
+        return json[hash] || null;
+    }
+    catch (e) {
+        return null;
+    }
+}
+/**
+ * Caches scan finding results locally inside cache.json.
+ */
+export function setCache(hash, payload) {
+    try {
+        let cache = {};
+        if (fs.existsSync(CACHE_FILE)) {
+            const data = fs.readFileSync(CACHE_FILE, "utf-8");
+            cache = JSON.parse(data);
+        }
+        else {
+            const dir = path.dirname(CACHE_FILE);
+            if (!fs.existsSync(dir)) {
+                fs.mkdirSync(dir, { recursive: true });
+            }
+        }
+        cache[hash] = payload;
+        fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2), "utf-8");
+    }
+    catch (e) {
+        // Fail silently to prevent cache issues from blocking core review execution
+    }
+}

package/dist/core/reporter.js

@@ -1,5 +1,6 @@
 import fs from "fs";
 import path from "path";
+import { calculateGrade, getGradeColor, generateBadge } from "./stats.js";
 /**
  * Helper to get a sanitized project name.
  */
@@ -80,6 +81,9 @@ export function writeHTMLReport(sessionDir, totalFiles, allFindings) {
     const projectName = getProjectName();
     const timestamp = new Date().toLocaleString();
     const data = JSON.stringify(allFindings);
+    const grade = calculateGrade(allFindings);
+    const gradeColor = getGradeColor(grade);
+    generateBadge(grade);
     const htmlContent = `
 <!DOCTYPE html>
 <html lang="en">
@@ -502,7 +506,7 @@ export function writeHTMLReport(sessionDir, totalFiles, allFindings) {
               <polygon points="60,52 54,50 56,56" fill="#00F0FF" />
             </svg>
             <div class="brand-text">
-                <h1>Pika <span>Sentinel</span></h1>
+                <h1 style="display: flex; align-items: center; gap: 8px;">Pika <span>Sentinel</span> <span style="font-size: 0.8rem; background: ${gradeColor}; color: #000; padding: 2px 6px; border-radius: 4px; font-weight: 800; text-shadow: none;">${grade}</span></h1>
                 <p>${projectName} • ${timestamp}</p>
             </div>
         </div>

package/dist/core/scanner.js

@@ -9,6 +9,7 @@ import { getIgnoredFiles } from "../utils/config.js";
 import { logger } from "../utils/logger.js";
 import path from "path";
 import { validateTokenLimit } from "../utils/token.js";
+import { computeScanHash, getCache, setCache } from "./cache.js";
 /**
  * Project Discovery: List all relevant files for interactive selection.
  */
@@ -91,6 +92,35 @@ export async function runScan(target, isCI, specificFiles) {
             findings: []
         };
     }
+    // Load custom architecture rules content
+    let rulesContent = "";
+    try {
+        const rulesPath = path.join(process.cwd(), ".pika-rules.md");
+        if (fs.existsSync(rulesPath)) {
+            rulesContent = fs.readFileSync(rulesPath, "utf-8");
+        }
+    }
+    catch (e) { }
+    // Gather target file content profiles
+    const fileStates = [];
+    for (const file of files) {
+        try {
+            if (fs.existsSync(file)) {
+                const content = fs.readFileSync(file, "utf-8");
+                fileStates.push({ filePath: file, content });
+            }
+        }
+        catch (e) { }
+    }
+    // Compute semantic hash and check database
+    const scanHash = computeScanHash(fileStates, rulesContent);
+    const cachedResult = getCache(scanHash);
+    if (cachedResult) {
+        if (!isCI) {
+            console.log(`\n  ${chalk.cyan("✓")}  ${chalk.bold("Instant Cache Hit: Loading results from local cache database (0ms).")}\n`);
+        }
+        return cachedResult;
+    }
     const reportDir = setupReportDir();
     if (!isCI)
         logger.info(`Initializing Pika Review on ${files.length} file(s)...`);
@@ -197,9 +227,11 @@ export async function runScan(target, isCI, specificFiles) {
     if (!isCI) {
         logger.success("\nScan complete!");
     }
-    return {
+    const payload = {
         markdownReports: generatedReports,
         htmlReport: htmlPath,
         findings: allFindings
     };
+    setCache(scanHash, payload);
+    return payload;
 }

package/dist/core/stats.js

@@ -0,0 +1,81 @@
+import fs from "fs";
+import path from "path";
+const BADGE_FILE = path.join(process.cwd(), "badge.svg");
+/**
+ * Computes the architectural grade based on the severities of identified findings.
+ */
+export function calculateGrade(findings) {
+    let criticalCount = 0;
+    let highCount = 0;
+    let mediumCount = 0;
+    findings.forEach((f) => {
+        f.reviews.forEach((r) => {
+            const severity = r.severity;
+            if (severity === "Critical")
+                criticalCount++;
+            else if (severity === "High")
+                highCount++;
+            else if (severity === "Medium")
+                mediumCount++;
+        });
+    });
+    if (criticalCount >= 2)
+        return "F";
+    if (criticalCount === 1)
+        return "C";
+    if (highCount >= 3)
+        return "C";
+    if (highCount >= 1 || mediumCount >= 4)
+        return "B";
+    if (mediumCount >= 1)
+        return "A";
+    return "A+";
+}
+/**
+ * Retrieves the HSL color code corresponding to a Sentinel Grade.
+ */
+export function getGradeColor(grade) {
+    switch (grade) {
+        case "A+": return "#00F0FF"; // Neon Cyan
+        case "A": return "#10B981"; // Emerald Green
+        case "B": return "#3B82F6"; // Royal Blue
+        case "C": return "#F59E0B"; // Amber Yellow
+        case "F": return "#EF4444"; // Ruby Red
+    }
+}
+/**
+ * Renders and saves a beautiful, high-quality, scalable SVG badge displaying the current Pika grade.
+ */
+export function generateBadge(grade) {
+    const color = getGradeColor(grade);
+    const svg = `<svg xmlns="http://www.w3.org/2000/svg" width="140" height="20" role="img" aria-label="Pika Sentinel: Grade ${grade}">
+  <linearGradient id="s" x2="0" y2="100%">
+    <stop offset="0" stop-color="#bbb" stop-opacity=".1"/>
+    <stop offset="1" stop-opacity=".1"/>
+  </linearGradient>
+  <clipPath id="r">
+    <rect width="140" height="20" rx="3" fill="#fff"/>
+  </clipPath>
+  <g clip-path="url(#r)">
+    <rect width="90" height="20" fill="#2d3748"/>
+    <rect x="90" width="50" height="20" fill="${color}"/>
+    <rect width="140" height="20" fill="url(#s)"/>
+  </g>
+  <g fill="#fff" text-anchor="middle" font-family="Verdana,Geneva,sans-serif" font-size="110">
+    <text aria-hidden="true" x="460" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="700">Pika Sentinel</text>
+    <text x="460" y="140" transform="scale(.1)" fill="#fff" textLength="700">Pika Sentinel</text>
+    <text aria-hidden="true" x="1150" y="150" fill="#010101" fill-opacity=".3" transform="scale(.1)" textLength="300">${grade}</text>
+    <text x="1150" y="140" transform="scale(.1)" fill="#fff" textLength="300">${grade}</text>
+  </g>
+</svg>`;
+    try {
+        const dir = path.dirname(BADGE_FILE);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        fs.writeFileSync(BADGE_FILE, svg, "utf-8");
+    }
+    catch (e) {
+        // Fail silently to keep stats errors isolated from blocking CLI scan operations
+    }
+}

package/dist/index.js

@@ -1,6 +1,9 @@
 #!/usr/bin/env node
 import { Command } from "commander";
 import chalk from "chalk";
+import fs from "fs";
+import path from "path";
+import { fileURLToPath } from "url";
 import { initAction } from "./cmd/init.js";
 import { scanAction } from "./cmd/scan.js";
 import { viewAction } from "./cmd/view.js";
@@ -8,15 +11,29 @@ import { statsAction } from "./cmd/stats.js";
 import { modelsAction } from "./cmd/models.js";
 import { hookAction } from "./cmd/hook.js";
 import { rulesAction } from "./cmd/rules.js";
+import { discussAction } from "./cmd/chat.js";
 import { logger } from "./utils/logger.js";
 /**
  * Pika Review: The Enterprise-Grade AI Code Reviewer.
  * Modular entry point for CLI operations.
  */
+// Get package.json version dynamically
+let version = "2.3.0";
+try {
+    const __filename = fileURLToPath(import.meta.url);
+    const __dirname = path.dirname(__filename);
+    const pkgPath = path.join(__dirname, "../package.json");
+    if (fs.existsSync(pkgPath)) {
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+        if (pkg.version)
+            version = pkg.version;
+    }
+}
+catch (e) { }
 const program = new Command();
 // Branding Header
 const BRAND = `
-  ${chalk.cyan.bold("◆  Pika Sentinel")}  ${chalk.dim(`v2.2.0 (Enterprise)`)}
+  ${chalk.cyan.bold("◆  Pika Sentinel")}  ${chalk.dim(`v${version} (Enterprise)`)}
   ${chalk.dim("─".repeat(42))}
   ${chalk.italic.gray("AI Architectural & Security Safeguard")}
 `;
@@ -27,9 +44,10 @@ const HELPER_TEXT = `
       -i, --interactive  Interactively pick files to scan
       --ci               Fail CI pipeline if critical/high issues are found
     ${chalk.bold("view")}               Open the latest interactive HTML report in browser
+    ${chalk.bold("discuss [file]")}     Launch an interactive Socratic chat session inside the console
     ${chalk.bold("stats")}              Print scan history & key quality trends
     ${chalk.bold("models")}             Interactively select Ollama models for offline audit
-    ${chalk.bold("hook")}               Install Git pre-commit scanner safeguard hook
+    ${chalk.bold("hook")}               Install Git pre-commit safeguard hook
     ${chalk.bold("rules")}              AI-generate architectural '.pika-rules.md'
 
   ${chalk.cyan.bold("Options & Advanced:")}
@@ -40,7 +58,7 @@ const HELPER_TEXT = `
 program
     .name("pika-review")
     .description("Enterprise-grade AI Architectural Code Reviewer")
-    .version("2.2.0")
+    .version(version)
     .addHelpText("before", BRAND)
     .addHelpText("after", HELPER_TEXT);
 program
@@ -96,6 +114,13 @@ program
         logger.info("Use 'pika-review rules --generate' to auto-generate architecture rules.");
     }
 });
+program
+    .command("discuss <file>")
+    .description("Launch an interactive Socratic chat session inside the console focusing on design context")
+    .action(async (file) => {
+    console.log(BRAND);
+    await discussAction(file);
+});
 program
     .command("scan [files...]", { isDefault: true }) // Set scan as the default command
     .description("Scan git changes or specific files for architectural anomalies")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pika-review",
-  "version": "2.2.0",
+  "version": "2.3.0",
   "description": "Enterprise-grade AI Architectural Code Reviewer.",
   "main": "./dist/index.js",
   "type": "module",