kramscan 0.1.0 → 0.2.0

package/dist/agent/confirmation.js

@@ -0,0 +1,210 @@
+"use strict";
+/**
+ * Confirmation Prompt System
+ * Handles user confirmation for skill execution with detailed risk assessment
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationHandler = void 0;
+const readline = __importStar(require("readline"));
+const chalk_1 = __importDefault(require("chalk"));
+class ConfirmationHandler {
+    rl = null;
+    ownsRl = false;
+    constructor(rl) {
+        if (rl) {
+            this.rl = rl;
+            this.ownsRl = false;
+        }
+    }
+    setInterface(rl) {
+        // Prefer sharing a single readline interface to avoid double-reading stdin.
+        this.rl = rl;
+        this.ownsRl = false;
+    }
+    getInterface() {
+        if (!this.rl) {
+            this.rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            this.ownsRl = true;
+        }
+        return this.rl;
+    }
+    /**
+     * Display confirmation prompt and get user response
+     */
+    async prompt(confirmation) {
+        console.log("");
+        console.log(chalk_1.default.bold.yellow("⚠️  Action Requires Confirmation"));
+        console.log(chalk_1.default.gray("─".repeat(50)));
+        console.log("");
+        // Display action details
+        console.log(chalk_1.default.white("Action:"), chalk_1.default.cyan(confirmation.action));
+        console.log(chalk_1.default.white("Description:"), confirmation.description);
+        console.log("");
+        // Display risk level with color coding
+        const riskColor = this.getRiskColor(confirmation.risk);
+        console.log(chalk_1.default.white("Risk Level:"), riskColor(confirmation.risk.toUpperCase()));
+        console.log(chalk_1.default.white("Estimated Time:"), confirmation.estimatedTime);
+        console.log("");
+        // Display parameters
+        console.log(chalk_1.default.white("Parameters:"));
+        Object.entries(confirmation.parameters).forEach(([key, value]) => {
+            const displayValue = typeof value === "object" ? JSON.stringify(value) : String(value);
+            console.log(`  ${chalk_1.default.gray(key)}: ${chalk_1.default.white(displayValue)}`);
+        });
+        console.log("");
+        // Risk warnings
+        if (confirmation.risk === "high") {
+            console.log(chalk_1.default.red.bold("⚠️  WARNING: This action may have significant impact."));
+        }
+        else if (confirmation.risk === "medium") {
+            console.log(chalk_1.default.yellow("⚠️  This action will interact with external systems."));
+        }
+        console.log("");
+        // Get user input
+        return this.getUserInput();
+    }
+    /**
+     * Quick confirmation for low-risk actions
+     */
+    async quickConfirm(action) {
+        const rl = this.getInterface();
+        return new Promise((resolve) => {
+            rl.question(chalk_1.default.gray(`${action} [Y/n]: `), (answer) => {
+                const normalized = answer.trim().toLowerCase();
+                resolve(normalized === "" || normalized === "y" || normalized === "yes");
+            });
+        });
+    }
+    /**
+     * Display detailed information about the action
+     */
+    showDetails(confirmation) {
+        console.log("");
+        console.log(chalk_1.default.bold.cyan("📋 Action Details"));
+        console.log(chalk_1.default.gray("─".repeat(50)));
+        console.log("");
+        console.log(chalk_1.default.white("What will happen:"));
+        console.log(chalk_1.default.gray(this.getDetailedDescription(confirmation.action)));
+        console.log("");
+        console.log(chalk_1.default.white("Safety considerations:"));
+        console.log(chalk_1.default.gray(this.getSafetyInfo(confirmation.risk)));
+        console.log("");
+        if (confirmation.risk === "high") {
+            console.log(chalk_1.default.yellow("Recommendations:"));
+            console.log(chalk_1.default.gray("• Ensure you have proper authorization"));
+            console.log(chalk_1.default.gray("• Verify the target is correct"));
+            console.log(chalk_1.default.gray("• Consider testing in a safe environment first"));
+            console.log("");
+        }
+    }
+    /**
+     * Close the readline interface
+     */
+    close() {
+        if (this.rl && this.ownsRl) {
+            this.rl.close();
+        }
+    }
+    async getUserInput() {
+        const rl = this.getInterface();
+        return new Promise((resolve) => {
+            const askQuestion = () => {
+                rl.question(chalk_1.default.gray("Proceed? [Y/n/details/cancel]: "), (answer) => {
+                    const normalized = answer.trim().toLowerCase();
+                    if (normalized === "" || normalized === "y" || normalized === "yes") {
+                        resolve({ confirmed: true, showDetails: false, cancelled: false });
+                    }
+                    else if (normalized === "n" || normalized === "no") {
+                        resolve({ confirmed: false, showDetails: false, cancelled: false });
+                    }
+                    else if (normalized === "details" || normalized === "d") {
+                        resolve({ confirmed: false, showDetails: true, cancelled: false });
+                    }
+                    else if (normalized === "cancel" || normalized === "c") {
+                        resolve({ confirmed: false, showDetails: false, cancelled: true });
+                    }
+                    else {
+                        console.log(chalk_1.default.gray("Please enter: Y, n, details, or cancel"));
+                        askQuestion();
+                    }
+                });
+            };
+            askQuestion();
+        });
+    }
+    getRiskColor(risk) {
+        switch (risk) {
+            case "high":
+                return chalk_1.default.red.bold;
+            case "medium":
+                return chalk_1.default.yellow;
+            case "low":
+                return chalk_1.default.green;
+            default:
+                return chalk_1.default.gray;
+        }
+    }
+    getDetailedDescription(action) {
+        const descriptions = {
+            "Web Scan": "This will crawl the target website and test for common vulnerabilities including XSS, SQL injection, CSRF, and security header misconfigurations. The scan sends HTTP requests to the target.",
+            "Analyze Findings": "This will use AI to analyze previously discovered vulnerabilities and provide detailed remediation recommendations.",
+            "Generate Report": "This will create a professional security report document based on scan results.",
+            "Check Environment": "This will verify your system configuration, API keys, and dependencies.",
+            "View Configuration": "This will display your current KramScan configuration settings.",
+        };
+        return (descriptions[action] ||
+            "This action will execute the requested security operation.");
+    }
+    getSafetyInfo(risk) {
+        switch (risk) {
+            case "high":
+                return "This action may trigger security systems, generate significant network traffic, or have other notable effects. Use with caution.";
+            case "medium":
+                return "This action will make network requests to external systems. Ensure you have permission to test the target.";
+            case "low":
+                return "This is a safe, read-only operation that won't modify any external systems.";
+            default:
+                return "Please review the action details carefully before proceeding.";
+        }
+    }
+}
+exports.ConfirmationHandler = ConfirmationHandler;

package/dist/agent/context.d.ts

@@ -0,0 +1,81 @@
+/**
+ * Conversation Context Manager
+ * Manages conversation history, user context, and session state
+ */
+import { ConversationMessage, AgentContext, AgentConfig } from "./types";
+export declare class ConversationContext {
+    private messages;
+    private context;
+    private config;
+    private historyFile;
+    constructor(config?: Partial<AgentConfig>);
+    private initializeContext;
+    /**
+     * Get the current agent context
+     */
+    getContext(): AgentContext;
+    /**
+     * Update the current target URL
+     */
+    setCurrentTarget(target: string): void;
+    /**
+     * Get the current target URL
+     */
+    getCurrentTarget(): string | undefined;
+    /**
+     * Store last scan results
+     */
+    setLastScanResults(results: unknown): void;
+    /**
+     * Get last scan results
+     */
+    getLastScanResults(): unknown | undefined;
+    /**
+     * Add a message to the conversation
+     */
+    addMessage(role: ConversationMessage["role"], content: string, toolCalls?: any[], toolCallResults?: any[]): ConversationMessage;
+    /**
+     * Get all conversation messages
+     */
+    getMessages(): ConversationMessage[];
+    /**
+     * Get recent messages (for AI context)
+     */
+    getRecentMessages(count?: number): ConversationMessage[];
+    /**
+     * Get the last message
+     */
+    getLastMessage(): ConversationMessage | undefined;
+    /**
+     * Get conversation summary for display
+     */
+    getSummary(): {
+        totalMessages: number;
+        sessionDuration: string;
+        currentTarget?: string;
+        hasScanResults: boolean;
+    };
+    /**
+     * Clear conversation history
+     */
+    clear(): void;
+    /**
+     * Trim history to max length
+     */
+    private trimHistory;
+    /**
+     * Persist conversation to disk
+     */
+    save(): Promise<void>;
+    /**
+     * Load conversation from disk
+     */
+    load(): Promise<boolean>;
+    /**
+     * Format messages for AI provider (OpenAI/Anthropic format)
+     */
+    formatForAI(): Array<{
+        role: string;
+        content: string;
+    }>;
+}

package/dist/agent/context.js

@@ -0,0 +1,227 @@
+"use strict";
+/**
+ * Conversation Context Manager
+ * Manages conversation history, user context, and session state
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConversationContext = void 0;
+const types_1 = require("./types");
+const uuid_1 = require("uuid");
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+class ConversationContext {
+    messages = [];
+    context;
+    config;
+    historyFile;
+    constructor(config = {}) {
+        this.config = { ...types_1.DEFAULT_AGENT_CONFIG, ...config };
+        this.context = this.initializeContext();
+        this.historyFile = path.join(os.homedir(), ".kramscan", "agent-history.json");
+    }
+    initializeContext() {
+        return {
+            sessionId: (0, uuid_1.v4)(),
+            userId: os.userInfo().username,
+            startTime: new Date(),
+            workingDirectory: process.cwd(),
+            environment: {
+                nodeVersion: process.version,
+                platform: process.platform,
+            },
+        };
+    }
+    /**
+     * Get the current agent context
+     */
+    getContext() {
+        return { ...this.context };
+    }
+    /**
+     * Update the current target URL
+     */
+    setCurrentTarget(target) {
+        this.context.currentTarget = target;
+    }
+    /**
+     * Get the current target URL
+     */
+    getCurrentTarget() {
+        return this.context.currentTarget;
+    }
+    /**
+     * Store last scan results
+     */
+    setLastScanResults(results) {
+        this.context.lastScanResults = results;
+    }
+    /**
+     * Get last scan results
+     */
+    getLastScanResults() {
+        return this.context.lastScanResults;
+    }
+    /**
+     * Add a message to the conversation
+     */
+    addMessage(role, content, toolCalls, toolCallResults) {
+        const message = {
+            id: (0, uuid_1.v4)(),
+            role,
+            content,
+            timestamp: new Date(),
+            toolCalls,
+            toolCallResults,
+        };
+        this.messages.push(message);
+        this.trimHistory();
+        return message;
+    }
+    /**
+     * Get all conversation messages
+     */
+    getMessages() {
+        return [...this.messages];
+    }
+    /**
+     * Get recent messages (for AI context)
+     */
+    getRecentMessages(count = this.config.maxConversationHistory) {
+        return this.messages.slice(-count);
+    }
+    /**
+     * Get the last message
+     */
+    getLastMessage() {
+        return this.messages[this.messages.length - 1];
+    }
+    /**
+     * Get conversation summary for display
+     */
+    getSummary() {
+        const duration = Date.now() - this.context.startTime.getTime();
+        const hours = Math.floor(duration / (1000 * 60 * 60));
+        const minutes = Math.floor((duration % (1000 * 60 * 60)) / (1000 * 60));
+        const seconds = Math.floor((duration % (1000 * 60)) / 1000);
+        let sessionDuration;
+        if (hours > 0) {
+            sessionDuration = `${hours}h ${minutes}m ${seconds}s`;
+        }
+        else if (minutes > 0) {
+            sessionDuration = `${minutes}m ${seconds}s`;
+        }
+        else {
+            sessionDuration = `${seconds}s`;
+        }
+        return {
+            totalMessages: this.messages.length,
+            sessionDuration,
+            currentTarget: this.context.currentTarget,
+            hasScanResults: !!this.context.lastScanResults,
+        };
+    }
+    /**
+     * Clear conversation history
+     */
+    clear() {
+        this.messages = [];
+        this.context.currentTarget = undefined;
+        this.context.lastScanResults = undefined;
+    }
+    /**
+     * Trim history to max length
+     */
+    trimHistory() {
+        if (this.messages.length > this.config.maxConversationHistory * 2) {
+            // Keep system message if present, then last N messages
+            const systemMessages = this.messages.filter((m) => m.role === "system");
+            const recentMessages = this.messages.slice(-this.config.maxConversationHistory);
+            this.messages = [...systemMessages, ...recentMessages];
+        }
+    }
+    /**
+     * Persist conversation to disk
+     */
+    async save() {
+        try {
+            const data = {
+                context: this.context,
+                messages: this.messages,
+                timestamp: new Date().toISOString(),
+            };
+            const dir = path.dirname(this.historyFile);
+            await fs.mkdir(dir, { recursive: true });
+            await fs.writeFile(this.historyFile, JSON.stringify(data, null, 2));
+        }
+        catch (error) {
+            console.error("Failed to save conversation history:", error);
+        }
+    }
+    /**
+     * Load conversation from disk
+     */
+    async load() {
+        try {
+            const data = await fs.readFile(this.historyFile, "utf-8");
+            const parsed = JSON.parse(data);
+            if (parsed.context) {
+                this.context = { ...this.context, ...parsed.context };
+            }
+            if (parsed.messages) {
+                this.messages = parsed.messages.map((m) => ({
+                    ...m,
+                    timestamp: new Date(m.timestamp),
+                }));
+            }
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Format messages for AI provider (OpenAI/Anthropic format)
+     */
+    formatForAI() {
+        // Include system messages so the model receives core constraints and tool format instructions.
+        return this.messages.map((m) => ({
+            role: m.role,
+            content: m.content,
+        }));
+    }
+}
+exports.ConversationContext = ConversationContext;

package/dist/agent/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Agent Module Index
+ * Main exports for the AI Agent system
+ */
+export { AgentOrchestrator } from "./orchestrator";
+export { ConversationContext } from "./context";
+export { SkillRegistry, skillRegistry } from "./skill-registry";
+export { ConfirmationHandler } from "./confirmation";
+export * from "./types";
+export * from "./skills";

package/dist/agent/index.js

@@ -0,0 +1,32 @@
+"use strict";
+/**
+ * Agent Module Index
+ * Main exports for the AI Agent system
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConfirmationHandler = exports.skillRegistry = exports.SkillRegistry = exports.ConversationContext = exports.AgentOrchestrator = void 0;
+var orchestrator_1 = require("./orchestrator");
+Object.defineProperty(exports, "AgentOrchestrator", { enumerable: true, get: function () { return orchestrator_1.AgentOrchestrator; } });
+var context_1 = require("./context");
+Object.defineProperty(exports, "ConversationContext", { enumerable: true, get: function () { return context_1.ConversationContext; } });
+var skill_registry_1 = require("./skill-registry");
+Object.defineProperty(exports, "SkillRegistry", { enumerable: true, get: function () { return skill_registry_1.SkillRegistry; } });
+Object.defineProperty(exports, "skillRegistry", { enumerable: true, get: function () { return skill_registry_1.skillRegistry; } });
+var confirmation_1 = require("./confirmation");
+Object.defineProperty(exports, "ConfirmationHandler", { enumerable: true, get: function () { return confirmation_1.ConfirmationHandler; } });
+__exportStar(require("./types"), exports);
+__exportStar(require("./skills"), exports);

package/dist/agent/orchestrator.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Agent Orchestrator
+ * Coordinates AI conversations, tool calling, skill execution, and user interactions
+ */
+import { ConversationContext } from "./context";
+import { SkillRegistry } from "./skill-registry";
+import { AgentConfig, AgentResponse } from "./types";
+import type * as readline from "readline";
+export declare class AgentOrchestrator {
+    private context;
+    private skillRegistry;
+    private confirmationHandler;
+    private config;
+    private aiClient;
+    private isRunning;
+    constructor(skillRegistry: SkillRegistry, config?: Partial<AgentConfig>);
+    setReadlineInterface(rl: readline.Interface): void;
+    /**
+     * Initialize the orchestrator and AI client
+     */
+    initialize(): Promise<void>;
+    /**
+     * Process a user message and generate a response
+     */
+    processUserMessage(userInput: string): Promise<AgentResponse>;
+    /**
+     * Execute a specific tool/skill directly
+     */
+    executeTool(toolName: string, parameters: Record<string, unknown>, skipConfirmation?: boolean): Promise<AgentResponse>;
+    /**
+     * Get conversation summary
+     */
+    getConversationSummary(): ReturnType<ConversationContext["getSummary"]>;
+    /**
+     * Clear conversation history
+     */
+    clearConversation(): void;
+    /**
+     * Save conversation state
+     */
+    saveState(): Promise<void>;
+    /**
+     * Get available skills list
+     */
+    getAvailableSkills(): ReturnType<SkillRegistry["listSkills"]>;
+    /**
+     * Shutdown the orchestrator
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Check if orchestrator is running
+     */
+    isActive(): boolean;
+    /**
+     * Start the agent session
+     */
+    start(): void;
+    private getAIResponse;
+    private buildPromptWithTools;
+    private parseToolCalls;
+    private handleToolExecution;
+    private formatToolResult;
+}