ahok-skill 1.3.1

package/dist/server/routes/dynamics.js

@@ -0,0 +1,312 @@
+"use strict";
+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.dynroutes = dynroutes;
+const db_1 = require("../../core/db");
+const dynamics_1 = require("../../ops/dynamics");
+function dynroutes(app) {
+    app.get("/dynamics/constants", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const advanced_memory_dynamics_configuration_constants = {
+                alpha_learning_rate_for_recall_reinforcement_value: dynamics_1.ALPHA_LEARNING_RATE_FOR_RECALL_REINFORCEMENT,
+                beta_learning_rate_for_emotional_frequency_value: dynamics_1.BETA_LEARNING_RATE_FOR_EMOTIONAL_FREQUENCY,
+                gamma_attenuation_constant_for_graph_distance_value: dynamics_1.GAMMA_ATTENUATION_CONSTANT_FOR_GRAPH_DISTANCE,
+                theta_consolidation_coefficient_for_long_term_memory: dynamics_1.THETA_CONSOLIDATION_COEFFICIENT_FOR_LONG_TERM,
+                eta_reinforcement_factor_for_trace_learning_value: dynamics_1.ETA_REINFORCEMENT_FACTOR_FOR_TRACE_LEARNING,
+                lambda_one_fast_decay_rate_for_short_term: dynamics_1.LAMBDA_ONE_FAST_DECAY_RATE,
+                lambda_two_slow_decay_rate_for_consolidation: dynamics_1.LAMBDA_TWO_SLOW_DECAY_RATE,
+                tau_energy_threshold_for_retrieval_cutoff: dynamics_1.TAU_ENERGY_THRESHOLD_FOR_RETRIEVAL,
+                sectoral_interdependence_matrix_for_cross_sector_resonance: dynamics_1.SECTORAL_INTERDEPENDENCE_MATRIX_FOR_COGNITIVE_RESONANCE,
+            };
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                dynamics_constants_configuration: advanced_memory_dynamics_configuration_constants,
+            });
+        }
+        catch (unexpected_error_during_constants_retrieval) {
+            console.error("[DYNAMICS] Error retrieving dynamics constants:", unexpected_error_during_constants_retrieval);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/dynamics/salience/calculate", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const incoming_request_body_payload = incoming_http_request.body;
+            const initial_salience_value_from_request = incoming_request_body_payload.initial_salience || 0.5;
+            const lambda_decay_constant_from_request = incoming_request_body_payload.decay_lambda || 0.01;
+            const recall_reinforcement_count_from_request = incoming_request_body_payload.recall_count || 0;
+            const emotional_frequency_metric_from_request = incoming_request_body_payload.emotional_frequency || 0;
+            const time_elapsed_in_days_from_request = incoming_request_body_payload.time_elapsed_days || 0;
+            const calculated_dynamic_salience_result = await (0, dynamics_1.calculateDynamicSalienceWithTimeDecay)(initial_salience_value_from_request, lambda_decay_constant_from_request, recall_reinforcement_count_from_request, emotional_frequency_metric_from_request, time_elapsed_in_days_from_request);
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                calculated_salience_value: calculated_dynamic_salience_result,
+                input_parameters_used: {
+                    initial_salience: initial_salience_value_from_request,
+                    decay_lambda: lambda_decay_constant_from_request,
+                    recall_count: recall_reinforcement_count_from_request,
+                    emotional_frequency: emotional_frequency_metric_from_request,
+                    time_elapsed_days: time_elapsed_in_days_from_request,
+                },
+            });
+        }
+        catch (unexpected_error_during_salience_calculation) {
+            console.error("[DYNAMICS] Error calculating dynamic salience:", unexpected_error_during_salience_calculation);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/dynamics/resonance/calculate", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const incoming_request_body_payload = incoming_http_request.body;
+            const memory_sector_type_from_request = incoming_request_body_payload.memory_sector || "semantic";
+            const query_sector_type_from_request = incoming_request_body_payload.query_sector || "semantic";
+            const base_cosine_similarity_from_request = incoming_request_body_payload.base_similarity || 0.8;
+            const calculated_cross_sector_resonance_score = await (0, dynamics_1.calculateCrossSectorResonanceScore)(memory_sector_type_from_request, query_sector_type_from_request, base_cosine_similarity_from_request);
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                resonance_modulated_score: calculated_cross_sector_resonance_score,
+                input_parameters_used: {
+                    memory_sector: memory_sector_type_from_request,
+                    query_sector: query_sector_type_from_request,
+                    base_similarity: base_cosine_similarity_from_request,
+                },
+            });
+        }
+        catch (unexpected_error_during_resonance_calculation) {
+            console.error("[DYNAMICS] Error calculating cross-sector resonance:", unexpected_error_during_resonance_calculation);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/dynamics/retrieval/energy-based", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const incoming_request_body_payload = incoming_http_request.body;
+            const query_text_content_from_request = incoming_request_body_payload.query;
+            const query_sector_type_from_request = incoming_request_body_payload.sector || "semantic";
+            const minimum_energy_threshold_from_request = incoming_request_body_payload.min_energy ||
+                dynamics_1.TAU_ENERGY_THRESHOLD_FOR_RETRIEVAL;
+            if (!query_text_content_from_request) {
+                return outgoing_http_response
+                    .status(400)
+                    .json({ err: "query_required" });
+            }
+            const { embedForSector } = await Promise.resolve().then(() => __importStar(require("../../memory/embed")));
+            const query_vector_embedding_array = await embedForSector(query_text_content_from_request, query_sector_type_from_request);
+            const retrieved_memories_with_energy_scores = await (0, dynamics_1.retrieveMemoriesWithEnergyThresholding)(query_vector_embedding_array, query_sector_type_from_request, minimum_energy_threshold_from_request);
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                query_text: query_text_content_from_request,
+                query_sector: query_sector_type_from_request,
+                minimum_energy_threshold: minimum_energy_threshold_from_request,
+                retrieved_memories_count: retrieved_memories_with_energy_scores.length,
+                memories_with_activation_energy: retrieved_memories_with_energy_scores.map((memory_record) => ({
+                    memory_id: memory_record.id,
+                    memory_content: memory_record.content,
+                    primary_sector_classification: memory_record.primary_sector,
+                    salience_score: memory_record.salience,
+                    activation_energy_level: memory_record.activation_energy,
+                })),
+            });
+        }
+        catch (unexpected_error_during_energy_retrieval) {
+            console.error("[DYNAMICS] Error performing energy-based retrieval:", unexpected_error_during_energy_retrieval);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/dynamics/reinforcement/trace", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const incoming_request_body_payload = incoming_http_request.body;
+            const target_memory_id_from_request = incoming_request_body_payload.memory_id;
+            if (!target_memory_id_from_request) {
+                return outgoing_http_response
+                    .status(400)
+                    .json({ err: "memory_id_required" });
+            }
+            const memory_record_from_database = await db_1.q.get_mem.get(target_memory_id_from_request);
+            if (!memory_record_from_database) {
+                return outgoing_http_response
+                    .status(404)
+                    .json({ err: "memory_not_found" });
+            }
+            const current_salience_before_reinforcement = memory_record_from_database.salience;
+            const updated_salience_after_reinforcement = await (0, dynamics_1.applyRetrievalTraceReinforcementToMemory)(target_memory_id_from_request, current_salience_before_reinforcement);
+            await db_1.q.upd_seen.run(target_memory_id_from_request, Date.now(), updated_salience_after_reinforcement, Date.now());
+            const connected_waypoints_from_database = await db_1.q.get_waypoints_by_src.all(target_memory_id_from_request);
+            const linked_nodes_with_weights_array = connected_waypoints_from_database.map((waypoint_record) => ({
+                target_id: waypoint_record.dst_id,
+                weight: waypoint_record.weight,
+            }));
+            const propagated_reinforcement_updates_list = await (0, dynamics_1.propagateAssociativeReinforcementToLinkedNodes)(target_memory_id_from_request, updated_salience_after_reinforcement, linked_nodes_with_weights_array);
+            for (const reinforcement_update_record of propagated_reinforcement_updates_list) {
+                await db_1.q.upd_seen.run(reinforcement_update_record.node_id, Date.now(), reinforcement_update_record.new_salience, Date.now());
+            }
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                reinforced_memory_id: target_memory_id_from_request,
+                previous_salience_value: current_salience_before_reinforcement,
+                updated_salience_value: updated_salience_after_reinforcement,
+                salience_increase_amount: updated_salience_after_reinforcement -
+                    current_salience_before_reinforcement,
+                linked_nodes_reinforced_count: propagated_reinforcement_updates_list.length,
+                linked_nodes_updates: propagated_reinforcement_updates_list,
+            });
+        }
+        catch (unexpected_error_during_trace_reinforcement) {
+            console.error("[DYNAMICS] Error applying trace reinforcement:", unexpected_error_during_trace_reinforcement);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/dynamics/activation/spreading", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const incoming_request_body_payload = incoming_http_request.body;
+            const initial_memory_ids_array_from_request = incoming_request_body_payload.initial_memory_ids || [];
+            const maximum_spreading_iterations_from_request = incoming_request_body_payload.max_iterations || 3;
+            if (!Array.isArray(initial_memory_ids_array_from_request) ||
+                initial_memory_ids_array_from_request.length === 0) {
+                return outgoing_http_response
+                    .status(400)
+                    .json({ err: "initial_memory_ids_required" });
+            }
+            const spreading_activation_results_map = await (0, dynamics_1.performSpreadingActivationRetrieval)(initial_memory_ids_array_from_request, maximum_spreading_iterations_from_request);
+            const activation_results_as_array = Array.from(spreading_activation_results_map.entries())
+                .map(([memory_node_id, activation_energy_level]) => ({
+                memory_id: memory_node_id,
+                activation_level: activation_energy_level,
+            }))
+                .sort((first_entry, second_entry) => second_entry.activation_level -
+                first_entry.activation_level);
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                initial_activated_memories_count: initial_memory_ids_array_from_request.length,
+                maximum_iterations_performed: maximum_spreading_iterations_from_request,
+                total_activated_nodes_count: activation_results_as_array.length,
+                spreading_activation_results: activation_results_as_array,
+            });
+        }
+        catch (unexpected_error_during_spreading_activation) {
+            console.error("[DYNAMICS] Error performing spreading activation:", unexpected_error_during_spreading_activation);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.get("/dynamics/waypoints/graph", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const waypoint_graph_structure_from_database = await (0, dynamics_1.buildAssociativeWaypointGraphFromMemories)();
+            const graph_statistics_summary = {
+                total_nodes_in_graph: waypoint_graph_structure_from_database.size,
+                total_edges_across_all_nodes: 0,
+                average_edges_per_node: 0,
+                nodes_with_no_connections: 0,
+            };
+            const detailed_graph_nodes_array = [];
+            for (const [memory_node_identifier, node_data_structure,] of waypoint_graph_structure_from_database) {
+                const number_of_outgoing_edges = node_data_structure.connected_waypoint_edges.length;
+                graph_statistics_summary.total_edges_across_all_nodes +=
+                    number_of_outgoing_edges;
+                if (number_of_outgoing_edges === 0) {
+                    graph_statistics_summary.nodes_with_no_connections++;
+                }
+                detailed_graph_nodes_array.push({
+                    node_memory_id: memory_node_identifier,
+                    outgoing_edges_count: number_of_outgoing_edges,
+                    connected_targets: node_data_structure.connected_waypoint_edges.map((edge_record) => ({
+                        target_memory_id: edge_record.target_node_id,
+                        link_weight: edge_record.link_weight_value,
+                        time_gap_milliseconds: edge_record.time_gap_delta_t,
+                    })),
+                });
+            }
+            if (graph_statistics_summary.total_nodes_in_graph > 0) {
+                graph_statistics_summary.average_edges_per_node =
+                    graph_statistics_summary.total_edges_across_all_nodes /
+                        graph_statistics_summary.total_nodes_in_graph;
+            }
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                graph_summary_statistics: graph_statistics_summary,
+                detailed_node_information: detailed_graph_nodes_array,
+            });
+        }
+        catch (unexpected_error_building_waypoint_graph) {
+            console.error("[DYNAMICS] Error building waypoint graph:", unexpected_error_building_waypoint_graph);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/dynamics/waypoints/calculate-weight", async (incoming_http_request, outgoing_http_response) => {
+        try {
+            const incoming_request_body_payload = incoming_http_request.body;
+            const source_memory_id_from_request = incoming_request_body_payload.source_memory_id;
+            const target_memory_id_from_request = incoming_request_body_payload.target_memory_id;
+            if (!source_memory_id_from_request ||
+                !target_memory_id_from_request) {
+                return outgoing_http_response
+                    .status(400)
+                    .json({ err: "both_memory_ids_required" });
+            }
+            const source_memory_record = await db_1.q.get_mem.get(source_memory_id_from_request);
+            const target_memory_record = await db_1.q.get_mem.get(target_memory_id_from_request);
+            if (!source_memory_record || !target_memory_record) {
+                return outgoing_http_response
+                    .status(404)
+                    .json({ err: "one_or_both_memories_not_found" });
+            }
+            const source_memory_mean_vector = source_memory_record.mean_vec;
+            const target_memory_mean_vector = target_memory_record.mean_vec;
+            if (!source_memory_mean_vector || !target_memory_mean_vector) {
+                return outgoing_http_response
+                    .status(400)
+                    .json({ err: "memories_missing_embeddings" });
+            }
+            const { bufferToVector } = await Promise.resolve().then(() => __importStar(require("../../memory/embed")));
+            const source_vector_array = bufferToVector(source_memory_mean_vector);
+            const target_vector_array = bufferToVector(target_memory_mean_vector);
+            const time_gap_between_memories_milliseconds = Math.abs(source_memory_record.created_at -
+                target_memory_record.created_at);
+            const calculated_waypoint_link_weight = await (0, dynamics_1.calculateAssociativeWaypointLinkWeight)(source_vector_array, target_vector_array, time_gap_between_memories_milliseconds);
+            outgoing_http_response.json({
+                success_status_indicator: true,
+                source_memory_identifier: source_memory_id_from_request,
+                target_memory_identifier: target_memory_id_from_request,
+                calculated_link_weight_value: calculated_waypoint_link_weight,
+                time_gap_in_days: time_gap_between_memories_milliseconds / 86400000,
+                calculation_details: {
+                    temporal_decay_factor_applied: true,
+                    cosine_similarity_computed: true,
+                },
+            });
+        }
+        catch (unexpected_error_calculating_waypoint_weight) {
+            console.error("[DYNAMICS] Error calculating waypoint weight:", unexpected_error_calculating_waypoint_weight);
+            outgoing_http_response.status(500).json({ err: "internal" });
+        }
+    });
+}

package/dist/server/routes/ide.js

@@ -0,0 +1,280 @@
+"use strict";
+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.ide = ide;
+const db_1 = require("../../core/db");
+const hsg_1 = require("../../memory/hsg");
+const user_summary_1 = require("../../memory/user_summary");
+const utils_1 = require("../../utils");
+const crypto = __importStar(require("crypto"));
+function ide(app) {
+    app.post("/api/ide/events", async (req, res) => {
+        try {
+            const event_type = req.body.event_type;
+            const file_path = req.body.file_path || "unknown";
+            const content = req.body.content || "";
+            const session_id = req.body.session_id || "default";
+            const metadata = req.body.metadata || {};
+            const user_id = req.body.user_id || "anonymous";
+            if (!event_type)
+                return res.status(400).json({ err: "event_type_required" });
+            let memory_content = "";
+            if (event_type === "open") {
+                memory_content = `Opened file: ${file_path}`;
+            }
+            else if (event_type === "save") {
+                if (content) {
+                    memory_content = `Saved file: ${file_path}\n\n${content}`;
+                }
+                else {
+                    memory_content = `Saved file: ${file_path}`;
+                }
+            }
+            else if (event_type === "close") {
+                memory_content = `Closed file: ${file_path}`;
+            }
+            else {
+                memory_content = `[${event_type}] ${file_path}\n${content}`.trim();
+            }
+            const full_metadata = {
+                ...metadata,
+                ide_event_type: event_type,
+                ide_file_path: file_path,
+                ide_session_id: session_id,
+                ide_timestamp: Date.now(),
+                ide_mode: true,
+            };
+            const result = await (0, hsg_1.add_hsg_memory)(memory_content, undefined, full_metadata, user_id);
+            // Update user summary asynchronously
+            if (user_id && user_id !== "anonymous") {
+                (0, user_summary_1.update_user_summary)(user_id).catch(err => console.error("[IDE] Failed to update user summary:", err));
+            }
+            res.json({
+                success: true,
+                memory_id: result.id,
+                primary_sector: result.primary_sector,
+                sectors: result.sectors,
+            });
+        }
+        catch (err) {
+            console.error("[IDE] Error storing IDE event:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/api/ide/context", async (req, res) => {
+        try {
+            const query = req.body.query;
+            const k = req.body.k || req.body.limit || 5;
+            const session_id = req.body.session_id;
+            const file_path = req.body.file_path;
+            if (!query)
+                return res.status(400).json({ err: "query_required" });
+            const results = await (0, hsg_1.hsg_query)(query, k);
+            let filtered = results;
+            if (session_id) {
+                filtered = [];
+                for (const r of results) {
+                    const mem = await db_1.q.get_mem.get(r.id);
+                    if (mem) {
+                        const meta = (0, utils_1.p)(mem.meta);
+                        if (meta && meta.ide_session_id === session_id) {
+                            filtered.push(r);
+                        }
+                    }
+                }
+            }
+            if (file_path) {
+                filtered = filtered.filter((r) => r.content.includes(file_path));
+            }
+            const formatted = filtered.map((r) => ({
+                memory_id: r.id,
+                content: r.content,
+                primary_sector: r.primary_sector,
+                sectors: r.sectors,
+                score: r.score,
+                salience: r.salience,
+                last_seen_at: r.last_seen_at,
+                path: r.path,
+            }));
+            res.json({
+                success: true,
+                memories: formatted,
+                total: formatted.length,
+                query: query,
+            });
+        }
+        catch (err) {
+            console.error("[IDE] Error retrieving IDE context:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/api/ide/session/start", async (req, res) => {
+        try {
+            const user_id = req.body.user_id || "anonymous";
+            const project_name = req.body.project_name || "unknown";
+            const ide_name = req.body.ide_name || "unknown";
+            const session_id = `session_${Date.now()}_${crypto.randomBytes(7).toString("hex")}`;
+            const now_ts = Date.now();
+            const content = `Session started: ${user_id} in ${project_name} using ${ide_name}`;
+            const metadata = {
+                ide_session_id: session_id,
+                ide_user_id: user_id,
+                ide_project_name: project_name,
+                ide_name: ide_name,
+                session_start_time: now_ts,
+                session_type: "ide_session",
+                ide_mode: true,
+            };
+            const result = await (0, hsg_1.add_hsg_memory)(content, undefined, metadata, user_id);
+            if (user_id && user_id !== "anonymous") {
+                (0, user_summary_1.update_user_summary)(user_id).catch(err => console.error("[IDE] Failed to update summary on session start:", err));
+            }
+            res.json({
+                success: true,
+                session_id: session_id,
+                memory_id: result.id,
+                started_at: now_ts,
+                user_id: user_id,
+                project_name: project_name,
+                ide_name: ide_name,
+            });
+        }
+        catch (err) {
+            console.error("[IDE] Error starting IDE session:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+    app.post("/api/ide/session/end", async (req, res) => {
+        try {
+            const session_id = req.body.session_id;
+            const user_id = req.body.user_id || "anonymous";
+            if (!session_id)
+                return res.status(400).json({ err: "session_id_required" });
+            const now_ts = Date.now();
+            const all_memories = await db_1.q.all_mem.all(10000, 0);
+            const session_memories = all_memories.filter((m) => {
+                try {
+                    const meta = (0, utils_1.p)(m.meta);
+                    return meta && meta.ide_session_id === session_id;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const total_events = session_memories.length;
+            const sectors = {};
+            const files = new Set();
+            for (const m of session_memories) {
+                sectors[m.primary_sector] =
+                    (sectors[m.primary_sector] || 0) + 1;
+                try {
+                    const meta = (0, utils_1.p)(m.meta);
+                    if (meta &&
+                        meta.ide_file_path &&
+                        meta.ide_file_path !== "unknown") {
+                        files.add(meta.ide_file_path);
+                    }
+                }
+                catch { }
+            }
+            const summary = `Session ${session_id} ended. Events: ${total_events}, Files: ${files.size}, Sectors: ${(0, utils_1.j)(sectors)}`;
+            const metadata = {
+                ide_session_id: session_id,
+                session_end_time: now_ts,
+                session_type: "ide_session_end",
+                total_events: total_events,
+                sectors_distribution: sectors,
+                files_touched: Array.from(files),
+                ide_mode: true,
+            };
+            const result = await (0, hsg_1.add_hsg_memory)(summary, undefined, metadata, user_id);
+            if (user_id && user_id !== "anonymous") {
+                (0, user_summary_1.update_user_summary)(user_id).catch(err => console.error("[IDE] Failed to update summary on session end:", err));
+            }
+            res.json({
+                success: true,
+                session_id: session_id,
+                ended_at: now_ts,
+                summary_memory_id: result.id,
+                statistics: {
+                    total_events: total_events,
+                    sectors: sectors,
+                    unique_files: files.size,
+                    files: Array.from(files),
+                },
+            });
+        }
+        catch (err) {
+            console.error("[IDE] Error ending IDE session:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+    app.get("/api/ide/patterns/:session_id", async (req, res) => {
+        try {
+            const session_id = req.params.session_id;
+            if (!session_id)
+                return res.status(400).json({ err: "session_id_required" });
+            const all_memories = await db_1.q.all_mem.all(10000, 0);
+            const procedural = all_memories.filter((m) => {
+                if (m.primary_sector !== "procedural")
+                    return false;
+                try {
+                    const meta = (0, utils_1.p)(m.meta);
+                    return meta && meta.ide_session_id === session_id;
+                }
+                catch {
+                    return false;
+                }
+            });
+            const patterns = procedural.map((m) => ({
+                pattern_id: m.id,
+                description: m.content,
+                salience: m.salience,
+                detected_at: m.created_at,
+                last_reinforced: m.last_seen_at,
+            }));
+            res.json({
+                success: true,
+                session_id: session_id,
+                pattern_count: patterns.length,
+                patterns: patterns,
+            });
+        }
+        catch (err) {
+            console.error("[IDE] Error detecting patterns:", err);
+            res.status(500).json({ err: "internal" });
+        }
+    });
+}

package/dist/server/routes/index.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.routes = routes;
+const system_1 = require("./system");
+const memory_1 = require("./memory");
+const dynamics_1 = require("./dynamics");
+const ide_1 = require("./ide");
+const compression_1 = require("./compression");
+const langgraph_1 = require("./langgraph");
+const users_1 = require("./users");
+const temporal_1 = require("./temporal");
+const dashboard_1 = require("./dashboard");
+const vercel_1 = require("./vercel");
+const sources_1 = require("./sources");
+const auth_1 = require("./auth");
+const docs_1 = require("./docs");
+const keys_1 = require("./keys");
+function routes(app) {
+    (0, system_1.sys)(app);
+    (0, memory_1.mem)(app);
+    (0, dynamics_1.dynroutes)(app);
+    (0, ide_1.ide)(app);
+    (0, compression_1.compression)(app);
+    (0, langgraph_1.lg)(app);
+    (0, users_1.usr)(app);
+    (0, temporal_1.temporal)(app);
+    (0, dashboard_1.dash)(app);
+    (0, vercel_1.vercel)(app);
+    (0, sources_1.src)(app);
+    (0, auth_1.auth)(app);
+    (0, docs_1.docs_route)(app);
+    (0, keys_1.keys)(app);
+}