brasil-ceps-offline 1.0.2 → 1.0.3

package/dist/scripts/ai-updater.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * AI Updater: Agente de IA para descobrir e inserir novos CEPs
+ *
+ * Uso:
+ *   npx ts-node src/scripts/ai-updater.ts
+ *   OPENAI_API_KEY=sk-xxx npx ts-node src/scripts/ai-updater.ts
+ */
+export {};

package/dist/scripts/ai-updater.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * AI Updater: Agente de IA para descobrir e inserir novos CEPs
+ *
+ * Uso:
+ *   npx ts-node src/scripts/ai-updater.ts
+ *   OPENAI_API_KEY=sk-xxx npx ts-node src/scripts/ai-updater.ts
+ */
+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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const better_sqlite3_1 = __importDefault(require("better-sqlite3"));
+const openai_1 = __importDefault(require("openai"));
+class AiUpdater {
+    constructor() {
+        this.dbPath = path.join(__dirname, '../../.db/ceps.sqlite');
+        this.db = null;
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            throw new Error('OPENAI_API_KEY not configured');
+        }
+        this.client = new openai_1.default({ apiKey });
+        this.log('AI Updater started');
+    }
+    log(message) {
+        console.log(`[ai-updater] ${message}`);
+    }
+    error(message, err) {
+        console.error(`[ai-updater] ERROR: ${message}`);
+        if (err)
+            console.error(`[ai-updater] ${err.message}`);
+    }
+    success(message) {
+        console.log(`[ai-updater] SUCCESS: ${message}`);
+    }
+    validateDatabase() {
+        if (!fs.existsSync(this.dbPath)) {
+            this.error(`Database not found: ${this.dbPath}`);
+            throw new Error('Database not found');
+        }
+        this.log(`Database found: ${this.dbPath}`);
+    }
+    connectDatabase() {
+        try {
+            this.db = new better_sqlite3_1.default(this.dbPath);
+            this.success('Connected to database');
+        }
+        catch (err) {
+            this.error('Error connecting to database', err);
+            throw err;
+        }
+    }
+    closeDatabase() {
+        if (this.db) {
+            this.db.close();
+            this.log('Connection closed');
+        }
+    }
+    async extractCepsWithAI(inputText) {
+        try {
+            this.log('Sending text to OpenAI...');
+            const systemPrompt = 'You are an expert in Brazilian geographic data. Extract CEP information from unstructured text. ' +
+                'Return ONLY a JSON array in this format: [{cep, state, city, neighborhood, street}]. ' +
+                'CEP must be 8 digits (no formatting). State must be 2 uppercase letters. Validate all CEPs.';
+            const response = await this.client.chat.completions.create({
+                model: 'gpt-4o-mini',
+                messages: [
+                    {
+                        role: 'system',
+                        content: systemPrompt,
+                    },
+                    {
+                        role: 'user',
+                        content: `Extract CEPs from this text:\n\n${inputText}`,
+                    },
+                ],
+                temperature: 0.3,
+            });
+            const content = response.choices[0]?.message?.content;
+            if (!content) {
+                throw new Error('No response from OpenAI');
+            }
+            this.log(`Response received: ${content.substring(0, 100)}...`);
+            // Extract JSON array from response
+            const jsonMatch = content.match(/\[[\s\S]*\]/);
+            if (!jsonMatch) {
+                throw new Error('Could not extract JSON from response');
+            }
+            const ceps = JSON.parse(jsonMatch[0]);
+            // Validate CEPs
+            const validatedCeps = ceps.filter((cep) => {
+                if (!/^\d{8}$/.test(cep.cep)) {
+                    this.log(`Skipping invalid CEP: ${cep.cep}`);
+                    return false;
+                }
+                return true;
+            });
+            this.success(`Extracted and validated ${validatedCeps.length} CEPs`);
+            return validatedCeps;
+        }
+        catch (err) {
+            this.error('Error extracting CEPs with AI', err);
+            throw err;
+        }
+    }
+    insertCeps(ceps) {
+        if (!this.db || ceps.length === 0)
+            return;
+        try {
+            const transaction = this.db.transaction((records) => {
+                for (const record of records) {
+                    this.db.prepare('INSERT OR IGNORE INTO addresses (cep, state, city, neighborhood, street) VALUES (?, ?, ?, ?, ?)').run(record.cep, record.state, record.city, record.neighborhood, record.street);
+                }
+            });
+            transaction(ceps);
+            this.success(`${ceps.length} CEPs inserted into database`);
+        }
+        catch (err) {
+            this.error('Error inserting CEPs', err);
+            throw err;
+        }
+    }
+    async fetchNewCepsText() {
+        // In production, this would fetch from external API or system
+        // For now, return example data
+        return ('New CEPs discovered:\n\n' +
+            '1. Lins, SP - Residential Florescer neighborhood\n' +
+            '   - Rua das Rosas: CEP 16400500\n' +
+            '   - Rua dos Lirios: CEP 16400501\n' +
+            '   - Avenida Central: CEP 16400510\n\n' +
+            '2. Ribeirao Preto, SP - Urban expansion\n' +
+            '   - Rua das Flores: CEP 14025500\n' +
+            '   - Avenida Brasil: CEP 14025600');
+    }
+    async run() {
+        try {
+            this.validateDatabase();
+            this.connectDatabase();
+            this.log('Fetching new CEPs...');
+            const inputText = await this.fetchNewCepsText();
+            this.log(`Text received: ${inputText.substring(0, 50)}...`);
+            const extractedCeps = await this.extractCepsWithAI(inputText);
+            if (extractedCeps.length > 0) {
+                this.insertCeps(extractedCeps);
+                this.success('Pipeline completed successfully');
+            }
+            else {
+                this.log('No new CEPs to insert');
+            }
+        }
+        catch (err) {
+            this.error('Fatal error in pipeline', err);
+            process.exit(1);
+        }
+        finally {
+            this.closeDatabase();
+        }
+    }
+}
+// Execute
+const updater = new AiUpdater();
+updater.run().catch((err) => {
+    console.error('Critical error:', err);
+    process.exit(1);
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "brasil-ceps-offline",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Busca rápida de CEPs brasileiros com zero latência de rede - dados off-line usando SQLite",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,13 +11,13 @@
     "build": "tsc",
     "build:db": "ts-node scripts/builder/builder.ts",
     "builder": "ts-node src/builder.ts",
-    "postinstall": "node dist/scripts/download-db.js",
     "dev": "tsc --watch",
     "test": "jest",
     "prepare": "npm run build",
     "sync": "node dist/bin/sync.js",
     "sync:status": "node dist/bin/sync.js status",
-    "example": "ts-node examples/usage.ts"
+    "example": "ts-node examples/usage.ts",
+    "ai:update": "ts-node src/scripts/ai-updater.ts"
   },
   "keywords": [
     "cep",
@@ -40,7 +40,8 @@
     "ts-node": "^10.9.2",
     "jest": "^29.7.0",
     "ts-jest": "^29.1.1",
-    "csv-parse": "^5.5.6"
+    "csv-parse": "^5.5.6",
+    "openai": "^4.52.0"
   },
   "files": [
     "dist"