@ik-firewall/core 1.0.0

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@ik-firewall/core",
+  "version": "1.0.0",
+  "type": "module",
+  "description": "The core IK Firewall engine for semantic-driven AI optimization.",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "scripts"
+  ],
+  "scripts": {
+    "prepare": "npm run build",
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --watch --dts",
+    "lint": "eslint src/**/*.ts",
+    "test": "jest",
+    "setup-ai": "node scripts/master-setup.js",
+    "start-ai": "node scripts/start-ai.js",
+    "postinstall": "node scripts/setup-runtime.js"
+  },
+  "keywords": [
+    "ai",
+    "firewall",
+    "semantic",
+    "llm",
+    "optimization"
+  ],
+  "author": "Stefan Vasic",
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^25.0.10",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0"
+  }
+}

package/scripts/download-bin.js

@@ -0,0 +1,56 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const LLAMA_ZIP_URL = 'https://github.com/ggerganov/llama.cpp/releases/download/b4461/llama-b4461-bin-win-avx2-x64.zip';
+const BIN_DIR = path.join(__dirname, '..', '.bin');
+const ZIP_PATH = path.join(BIN_DIR, 'llama-bin.zip');
+
+async function downloadFile(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (response) => {
+            if (response.statusCode === 301 || response.statusCode === 302) {
+                downloadFile(response.headers.location, dest).then(resolve).catch(reject);
+                return;
+            }
+            response.pipe(file);
+            file.on('finish', () => {
+                file.close(() => resolve());
+            });
+        }).on('error', (err) => {
+            fs.unlink(dest, () => {});
+            reject(err);
+        });
+    });
+}
+
+async function setupLlamaBin() {
+    if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
+    try {
+        console.log('📡 Downloading precompiled llama.cpp binary...');
+        await downloadFile(LLAMA_ZIP_URL, ZIP_PATH);
+        console.log('✅ Download complete.');
+        
+        // Use tar -xf (supported on Windows 10/11)
+        console.log('📦 Extracting binary using tar...');
+        execSync(`tar -xf "${ZIP_PATH}" -C "${BIN_DIR}"`);
+        console.log('✅ Extraction complete.');
+        
+        console.log('🧹 Cleaning up...');
+        if (fs.existsSync(ZIP_PATH)) fs.unlinkSync(ZIP_PATH);
+        
+        console.log('✨ Local Llama ecosystem is ready.');
+    } catch (e) {
+        console.error('❌ Binary setup failed:', e.message);
+        console.log('💡 Note: If tar failed, you might need to manually unzip llama-bin.zip in the .bin folder.');
+    }
+}
+
+setupLlamaBin();

package/scripts/download-model.js

@@ -0,0 +1,51 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const MODEL_URL = 'https://huggingface.co/bartowski/Llama-3.2-1B-Instruct-GGUF/resolve/main/Llama-3.2-1B-Instruct-Q4_K_M.gguf?download=true';
+const BIN_DIR = path.join(__dirname, '..', '.bin');
+const MODEL_PATH = path.join(BIN_DIR, 'ik-local-1b-v1.gguf');
+
+async function downloadModel() {
+    if (!fs.existsSync(BIN_DIR)) {
+        fs.mkdirSync(BIN_DIR, { recursive: true });
+    }
+
+    if (fs.existsSync(MODEL_PATH) && fs.statSync(MODEL_PATH).size > 1000000) {
+        console.log('✅ Model already exists, skipping download.');
+        return;
+    }
+
+    console.log('📡 Downloading Llama-3.2-1B model (approx. 640MB)... This may take a few minutes.');
+    
+    // Deleting placeholder if exists
+    if (fs.existsSync(MODEL_PATH)) fs.unlinkSync(MODEL_PATH);
+
+    const file = fs.createWriteStream(MODEL_PATH);
+    
+    https.get(MODEL_URL, (response) => {
+        if (response.statusCode === 302 || response.statusCode === 301) {
+            // Handle redirect
+            https.get(response.headers.location, (res) => {
+                res.pipe(file);
+                res.on('end', () => {
+                    console.log('✅ Model download complete: ik-local-1b-v1.gguf');
+                });
+            });
+        } else {
+            response.pipe(file);
+            response.on('end', () => {
+                console.log('✅ Model download complete: ik-local-1b-v1.gguf');
+            });
+        }
+    }).on('error', (err) => {
+        console.error('❌ Download failed:', err.message);
+        fs.unlink(MODEL_PATH, () => {});
+    });
+}
+
+downloadModel();

package/scripts/master-setup.js

@@ -0,0 +1,102 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const BIN_DIR = path.join(__dirname, '..', '.bin');
+const MODEL_NAME = 'ik-local-1b-v1.gguf';
+const MODEL_PATH = path.join(BIN_DIR, MODEL_NAME);
+
+// Using stable, direct URLs from known mirrors to avoid redirect hell
+const CONFIG = {
+    modelUrl: 'https://huggingface.co/bartowski/Llama-3.2-1B-Instruct-GGUF/resolve/main/Llama-3.2-1B-Instruct-Q4_K_M.gguf?download=true',
+    serverUrl: 'https://github.com/ggml-org/llama.cpp/releases/download/b7708/llama-b7708-bin-win-cpu-x64.zip',
+    serverExe: 'llama-server.exe'
+};
+
+/**
+ * Robust HTTPS Downloader with redirect follow
+ */
+function download(url, dest) {
+    return new Promise((resolve, reject) => {
+        const file = fs.createWriteStream(dest);
+        https.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                file.close();
+                download(res.headers.location, dest).then(resolve).catch(reject);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                file.close();
+                fs.unlink(dest, () => {});
+                reject(new Error(`HTTP ${res.statusCode}: ${res.statusMessage}`));
+                return;
+            }
+            res.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }).on('error', (err) => {
+            file.close();
+            fs.unlink(dest, () => {});
+            reject(err);
+        });
+    });
+}
+
+async function setup() {
+    console.log('\n🧠 IK_FIREWALL: Initiating Zero-Config AI Setup...');
+    console.log('------------------------------------------------');
+
+    if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
+    // 1. Check Model
+    if (fs.existsSync(MODEL_PATH) && fs.statSync(MODEL_PATH).size > 100000000) {
+        console.log('✅ Local Model: DETECTED');
+    } else {
+        console.log('📡 Downloading 1B Model (~640MB). Please wait...');
+        try {
+            await download(CONFIG.modelUrl, MODEL_PATH);
+            console.log('✅ Local Model: INSTALLED');
+        } catch (e) {
+            console.error('❌ Failed to download model:', e.message);
+        }
+    }
+
+    // 2. Check Server
+    const serverPath = path.join(BIN_DIR, CONFIG.serverExe);
+    if (fs.existsSync(serverPath)) {
+        console.log('✅ AI Server Engine: DETECTED');
+    } else {
+        console.log('📡 Fetching AI Server Engine (Windows x64)...');
+        const zipPath = path.join(BIN_DIR, 'server.zip');
+        try {
+            await download(CONFIG.serverUrl, zipPath);
+            console.log('📦 Extracting server engine...');
+            
+            // Native Windows extraction via tar (faster and handle-safe)
+            try {
+                execSync(`tar -xf "${zipPath}" -C "${BIN_DIR}"`);
+            } catch (tarE) {
+                // Fallback for older Win10
+                execSync(`powershell -Command "Expand-Archive -Path '${zipPath}' -DestinationPath '${BIN_DIR}' -Force"`);
+            }
+            
+            fs.unlinkSync(zipPath);
+            console.log('✅ AI Server Engine: INSTALLED');
+        } catch (e) {
+            console.error('❌ Failed to setup server:', e.message);
+        }
+    }
+
+    console.log('------------------------------------------------');
+    console.log('✨ IK ARCHITECTURE IS ARMED AND READY.');
+    console.log('💡 Run "node scripts/start-ai.js" to begin local audit.');
+}
+
+setup();

package/scripts/robust-download.js

@@ -0,0 +1,67 @@
+import fs from 'fs';
+import path from 'path';
+import https from 'https';
+import { execSync } from 'child_process';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Tag b4461 seems stable, but let's try b7708 as it was found in latest
+const LLAMA_ZIP_URL = 'https://github.com/ggml-org/llama.cpp/releases/download/b4461/llama-b4461-bin-win-avx2-x64.zip';
+const BIN_DIR = path.join(__dirname, '..', '.bin');
+const ZIP_PATH = path.join(BIN_DIR, 'llama-bin.zip');
+
+async function download(url, dest) {
+    return new Promise((resolve, reject) => {
+        https.get(url, (res) => {
+            if (res.statusCode === 301 || res.statusCode === 302) {
+                console.log(`📡 Redirecting to: ${res.headers.location}`);
+                download(res.headers.location, dest).then(resolve).catch(reject);
+                return;
+            }
+            if (res.statusCode !== 200) {
+                reject(new Error(`Server responded with ${res.statusCode}: ${res.statusMessage}`));
+                return;
+            }
+            const file = fs.createWriteStream(dest);
+            res.pipe(file);
+            file.on('finish', () => {
+                file.close();
+                resolve();
+            });
+        }).on('error', (err) => {
+            fs.unlink(dest, () => {});
+            reject(err);
+        });
+    });
+}
+
+async function start() {
+    if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+    
+    try {
+        console.log(`🚀 Starting robust download from: ${LLAMA_ZIP_URL}`);
+        await download(LLAMA_ZIP_URL, ZIP_PATH);
+        console.log('✅ ZIP downloaded successfully.');
+        
+        console.log('📦 Extracting assets...');
+        // tar -xf is versatile and usually present in modern Windows
+        try {
+            execSync(`tar -xf "${ZIP_PATH}" -C "${BIN_DIR}"`);
+            console.log('✅ Extraction complete via tar.');
+        } catch (tarError) {
+            console.log('⚠️ tar failed, trying PowerShell Expand-Archive...');
+            execSync(`powershell -Command "Expand-Archive -Path '${ZIP_PATH}' -DestinationPath '${BIN_DIR}' -Force"`);
+            console.log('✅ Extraction complete via PowerShell.');
+        }
+        
+        fs.unlinkSync(ZIP_PATH);
+        console.log('✨ Cleanup done. Local engine is ARMED.');
+    } catch (err) {
+        console.error(`❌ FAILURE: ${err.message}`);
+        process.exit(1);
+    }
+}
+
+start();

package/scripts/runtime-emulator.js

@@ -0,0 +1,104 @@
+import http from 'http';
+
+const PORT = 8080;
+
+/**
+ * IK-RUNTIME EMULATOR (V1.0.0-PROTO)
+ * This script simulates the local 1B model server for development and testing.
+ */
+const server = http.createServer((req, res) => {
+    // Add CORS headers for local development if needed
+    res.setHeader('Access-Control-Allow-Origin', '*');
+    res.setHeader('Access-Control-Allow-Methods', 'POST, GET, OPTIONS');
+    res.setHeader('Access-Control-Allow-Headers', 'Content-Type');
+
+    if (req.method === 'OPTIONS') {
+        res.writeHead(204);
+        res.end();
+        return;
+    }
+
+    if (req.url === '/v1/chat/completions' && req.method === 'POST') {
+        let body = '';
+        req.on('data', chunk => { body += chunk.toString(); });
+        req.on('end', () => {
+            try {
+                const parsed = JSON.parse(body);
+                const userPrompt = parsed.messages?.[0]?.content || '';
+                
+                console.log(`[IK-RUNTIME] Received Audit Request: "${userPrompt.substring(0, 50)}..."`);
+
+                // Simulated 1B Model Logic: Semantic Analysis
+                const length = userPrompt.length;
+                const isEngineering = userPrompt.toLowerCase().includes('function') || userPrompt.toLowerCase().includes('code');
+                const isLegal = userPrompt.toLowerCase().includes('contract') || userPrompt.toLowerCase().includes('terms');
+
+                const mockResponse = {
+                    id: 'chatcmpl-mock-123',
+                    object: 'chat.completion',
+                    created: Date.now(),
+                    model: 'ik-local-1b-v1',
+                    choices: [{
+                        index: 0,
+                        message: {
+                            role: 'assistant',
+                            content: JSON.stringify({
+                                metaphoricalScale: 0.15,
+                                conceptualUnitsCount: Math.ceil(length / 20),
+                                redundancyRatio: 0.12,
+                                semanticProof: 0.95,
+                                cognitiveKinetic: 0.85,
+                                conceptualBlueprint: "SYSTEM_CORE_OPTIMIZED: Analyzing " + (isEngineering ? "Technical Structure" : "Conceptual Essence"),
+                                noiseClusters: ["redundant", "filler", "extra"],
+                                immutableEntities: isEngineering ? ["logic", "algorithm"] : ["intent", "value"],
+                                intentMode: isEngineering ? "ENGINEERING" : (isLegal ? "SPECIALIZED" : "CONCEPTUAL"),
+                                cognitiveDepth: "L2-ANALYTICAL",
+                                activeLayers: ["L1", "L2"],
+                                precisionRequired: isEngineering || isLegal,
+                                engine_tuning_recommendation: "Increase precisionBias for higher dm output.",
+                                detectedDomain: isEngineering ? "ENGINEERING" : (isLegal ? "LEGAL" : "GENERAL"),
+                                illocutionaryPoint: "ASSERTIVE",
+                                rhetoricalRatio: { ethos: 0.2, pathos: 0.1, logos: 0.7 },
+                                toneVector: { abstraction: 0.2, directness: 0.7, density: 0.5 },
+                                kft: isEngineering ? 8 : 4,
+                                opt: 3,
+                                approach: { category: isEngineering ? "PROBLEM_ORIENTED" : "DIRECTIVE", subtype: "analysis" }
+                            })
+                        },
+                        finish_reason: 'stop'
+                    }],
+                    usage: {
+                        prompt_tokens: Math.ceil(length / 4),
+                        completion_tokens: 150,
+                        total_tokens: Math.ceil(length / 4) + 150
+                    }
+                };
+
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify(mockResponse));
+                console.log(`✅ [IK-RUNTIME] Audit Delivered (Local).`);
+            } catch (e) {
+                res.writeHead(400);
+                res.end(JSON.stringify({ error: "Invalid JSON" }));
+            }
+        });
+    } else if (req.url === '/v1/health') {
+        res.writeHead(200, { 'Content-Type': 'application/json' });
+        res.end(JSON.stringify({ status: 'ok', engine: 'IK-Emulator-v1' }));
+    } else {
+        res.writeHead(404);
+        res.end();
+    }
+});
+
+server.listen(PORT, () => {
+    console.log(`
+  IK_FIREWALL: RUNTIME EMULATOR ACTIVE
+  -----------------------------------
+  Port:    ${PORT}
+  Mode:    Local Audit Simulation (1B)
+  Status:  Waiting for kognitive signals...
+  -----------------------------------
+  (Leave this window open for idea-analyzer to use Local Audit)
+    `);
+});

package/scripts/setup-runtime.js

@@ -0,0 +1,44 @@
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Constants
+const BIN_DIR = path.join(__dirname, '..', '.bin');
+const RUNTIME_NAME = process.platform === 'win32' ? 'ik-runtime.exe' : 'ik-runtime';
+const MODEL_NAME = 'ik-local-1b-v1.gguf';
+
+async function setup() {
+    if (process.env.CI || process.env.VERCEL) {
+        console.log('⏭️ IK_FIREWALL: CI/Vercel environment detected. Skipping local runtime setup.');
+        return;
+    }
+    console.log('🚀 IK_FIREWALL: Initiating Zero-Config Runtime Setup...');
+
+    // 1. Create .bin directory
+    if (!fs.existsSync(BIN_DIR)) {
+        fs.mkdirSync(BIN_DIR, { recursive: true });
+        console.log(`✅ Created directory: ${BIN_DIR}`);
+    }
+
+    // 2. Detect OS & Architecture
+    const platform = process.platform;
+    const arch = process.arch;
+    console.log(`🔍 Detected environment: ${platform}-${arch}`);
+
+    // 3. Inform user about the Emulator (since binary is OS-dependent)
+    const emulatorPath = path.join(__dirname, 'runtime-emulator.js');
+    console.log(`\n💡 TIP: For this prototype on Windows, use the Node.js Emulator instead of the .exe:`);
+    console.log(`   node scripts/runtime-emulator.js`);
+    
+    // Create a helper dev script in package.json context or similar
+    console.log('\n📦 IK-Runtime environment prepared.');
+    console.log('✨ IK Adapter is now ready for local escalation testing!');
+}
+
+setup().catch(err => {
+    console.error('❌ IK_FIREWALL Setup Failed:', err.message);
+    process.exit(1);
+});

package/scripts/start-ai.js

@@ -0,0 +1,38 @@
+import { spawn } from 'child_process';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const BIN_DIR = path.join(__dirname, '..', '.bin');
+const SERVER_EXE = path.join(BIN_DIR, 'llama-server.exe');
+const MODEL_FILE = path.join(BIN_DIR, 'ik-local-1b-v1.gguf');
+
+console.log(`
+  IK_FIREWALL: LOCAL RUNTIME ACTIVE
+  -----------------------------------
+  Engine:  llama.cpp (Real 1B Model)
+  Port:    8085
+  Context: 4096 tokens
+  Status:  Igniting Artificial Intelligence...
+  -----------------------------------
+`);
+
+const llama = spawn(SERVER_EXE, [
+    '-m', MODEL_FILE,
+    '--port', '8085',
+    '--ctx-size', '4096',
+    '--n-predict', '512',
+    '--threads', '4',
+    '--no-mmap' // Safer for some Windows setups
+], { stdio: 'inherit' });
+
+llama.on('error', (err) => {
+    console.error(`❌ Failed to start AI: ${err.message}`);
+    console.log('💡 TIP: Did you run "node scripts/master-setup.js" first?');
+});
+
+llama.on('close', (code) => {
+    console.log(`\n🛑 AI Server shutdown (Exit code: ${code})`);
+});