mistagent 0.1.1 → 0.1.2

package/dist/src/utils/constants.d.ts

@@ -1,4 +1,4 @@
-export declare const VERSION = "0.1.1";
+export declare const VERSION = "0.1.2";
 export declare const BANNER_LINES: string[];
 export declare const BANNER_SUBTITLE = "          A  G  E  N  T";
 export declare const BANNER_GRADIENT: string[];

package/dist/src/utils/constants.js

@@ -1,4 +1,4 @@
-export const VERSION = '0.1.1';
+export const VERSION = '0.1.2';
 // Banner as line array for per-line gradient coloring
 export const BANNER_LINES = [
     ' ███╗   ███╗██╗███████╗████████╗',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mistagent",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "MistAgent - Terminal AI Assistant",
   "type": "module",
   "main": "dist/index.js",
@@ -8,7 +8,8 @@
     "mist": "dist/index.js"
   },
   "files": [
-    "dist/"
+    "dist/",
+    "vendor/"
   ],
   "license": "MIT",
   "keywords": [

package/vendor/leiden/index.cjs

@@ -0,0 +1,355 @@
+/**
+ * Graphology Leiden Algorithm
+ * ============================
+ *
+ * JavaScript implementation of the Leiden community detection
+ * algorithm for graphology.
+ *
+ * Vendored from: https://github.com/graphology/graphology/tree/master/src/communities-leiden
+ * License: MIT
+ *
+ * [Reference]
+ * Traag, V. A., et al. "From Louvain to Leiden: Guaranteeing Well-Connected
+ * Communities". Scientific Reports, vol. 9, no 1, 2019, p. 5233.
+ * https://arxiv.org/abs/1810.08473
+ */
+var resolveDefaults = require('graphology-utils/defaults');
+var isGraph = require('graphology-utils/is-graph');
+var inferType = require('graphology-utils/infer-type');
+var SparseMap = require('mnemonist/sparse-map');
+var SparseQueueSet = require('mnemonist/sparse-queue-set');
+var createRandomIndex = require('pandemonium/random-index').createRandomIndex;
+var utils = require('./utils.cjs');
+
+var indices = require('graphology-indices/louvain');
+var addWeightToCommunity = utils.addWeightToCommunity;
+
+var UndirectedLouvainIndex = indices.UndirectedLouvainIndex;
+
+var UndirectedLeidenAddenda = utils.UndirectedLeidenAddenda;
+
+var DEFAULTS = {
+ attributes: {
+ community: 'community',
+ weight: 'weight'
+ },
+ randomness: 0.01,
+ randomWalk: true,
+ resolution: 1,
+ rng: Math.random,
+ weighted: false
+};
+
+var EPSILON = 1e-10;
+
+function tieBreaker(
+ bestCommunity,
+ currentCommunity,
+ targetCommunity,
+ delta,
+ bestDelta
+) {
+ if (Math.abs(delta - bestDelta) < EPSILON) {
+ if (bestCommunity === currentCommunity) {
+ return false;
+ } else {
+ return targetCommunity > bestCommunity;
+ }
+ } else if (delta > bestDelta) {
+ return true;
+ }
+
+ return false;
+}
+
+function undirectedLeiden(detailed, graph, options) {
+ var index = new UndirectedLouvainIndex(graph, {
+ attributes: {
+ weight: options.attributes.weight
+ },
+ keepDendrogram: detailed,
+ resolution: options.resolution,
+ weighted: options.weighted
+ });
+
+ var addenda = new UndirectedLeidenAddenda(index, {
+ randomness: options.randomness,
+ rng: options.rng
+ });
+
+ var randomIndex = createRandomIndex(options.rng);
+
+ // Communities
+ var currentCommunity, targetCommunity;
+ var communities = new SparseMap(Float64Array, index.C);
+
+ // Traversal
+ var queue = new SparseQueueSet(index.C),
+ start,
+ end,
+ weight,
+ ci,
+ ri,
+ s,
+ i,
+ j,
+ l;
+
+ // Metrics
+ var degree, targetCommunityDegree;
+
+ // Moves
+ var bestCommunity, bestDelta, deltaIsBetter, delta;
+
+ // Details
+ var deltaComputations = 0,
+ nodesVisited = 0,
+ moves = [],
+ currentMoves;
+
+ while (true) {
+ l = index.C;
+
+ currentMoves = 0;
+
+ // Traversal of the graph
+ ri = options.randomWalk ? randomIndex(l) : 0;
+
+ for (s = 0; s < l; s++, ri++) {
+ i = ri % l;
+ queue.enqueue(i);
+ }
+
+ while (queue.size !== 0) {
+ i = queue.dequeue();
+ nodesVisited++;
+
+ degree = 0;
+ communities.clear();
+
+ currentCommunity = index.belongings[i];
+
+ start = index.starts[i];
+ end = index.starts[i + 1];
+
+ // Traversing neighbors
+ for (; start < end; start++) {
+ j = index.neighborhood[start];
+ weight = index.weights[start];
+
+ targetCommunity = index.belongings[j];
+
+ // Incrementing metrics
+ degree += weight;
+ addWeightToCommunity(communities, targetCommunity, weight);
+ }
+
+ // Finding best community to move to
+ bestDelta = index.fastDeltaWithOwnCommunity(
+ i,
+ degree,
+ communities.get(currentCommunity) || 0,
+ currentCommunity
+ );
+ bestCommunity = currentCommunity;
+
+ for (ci = 0; ci < communities.size; ci++) {
+ targetCommunity = communities.dense[ci];
+
+ if (targetCommunity === currentCommunity) continue;
+
+ targetCommunityDegree = communities.vals[ci];
+
+ deltaComputations++;
+
+ delta = index.fastDelta(
+ i,
+ degree,
+ targetCommunityDegree,
+ targetCommunity
+ );
+
+ deltaIsBetter = tieBreaker(
+ bestCommunity,
+ currentCommunity,
+ targetCommunity,
+ delta,
+ bestDelta
+ );
+
+ if (deltaIsBetter) {
+ bestDelta = delta;
+ bestCommunity = targetCommunity;
+ }
+ }
+
+ if (bestDelta < 0) {
+ bestCommunity = index.isolate(i, degree);
+
+ if (bestCommunity === currentCommunity) continue;
+ } else {
+ if (bestCommunity === currentCommunity) {
+ continue;
+ } else {
+ index.move(i, degree, bestCommunity);
+ }
+ }
+
+ currentMoves++;
+
+ // Adding neighbors from other communities to the queue
+ start = index.starts[i];
+ end = index.starts[i + 1];
+
+ for (; start < end; start++) {
+ j = index.neighborhood[start];
+ targetCommunity = index.belongings[j];
+
+ if (targetCommunity !== bestCommunity) queue.enqueue(j);
+ }
+ }
+
+ moves.push(currentMoves);
+
+ if (currentMoves === 0) {
+ index.zoomOut();
+ break;
+ }
+
+ if (!addenda.onlySingletons()) {
+ // We continue working on the induced graph
+ addenda.zoomOut();
+ continue;
+ }
+
+ break;
+ }
+
+ var results = {
+ index: index,
+ deltaComputations: deltaComputations,
+ nodesVisited: nodesVisited,
+ moves: moves
+ };
+
+ return results;
+}
+
+/**
+ * Function returning the communities mapping of the graph.
+ *
+ * @param {boolean} assign - Assign communities to nodes attributes?
+ * @param {boolean} detailed - Whether to return detailed information.
+ * @param {Graph} graph - Target graph.
+ * @param {object} options - Options:
+ * @param {object} attributes - Attribute names:
+ * @param {string} community - Community node attribute name.
+ * @param {string} weight - Weight edge attribute name.
+ * @param {number} randomness - Randomness parameter.
+ * @param {boolean} randomWalk - Whether to traverse the graph in random order.
+ * @param {number} resolution - Resolution parameter.
+ * @param {function} rng - RNG function to use.
+ * @param {boolean} weighted - Whether to compute the weighted version.
+ * @return {object}
+ */
+function leiden(assign, detailed, graph, options) {
+ if (!isGraph(graph))
+ throw new Error(
+ 'graphology-communities-leiden: the given graph is not a valid graphology instance.'
+ );
+
+ var type = inferType(graph);
+
+ if (type === 'mixed')
+ throw new Error(
+ 'graphology-communities-leiden: cannot run the algorithm on a true mixed graph.'
+ );
+
+ if (type === 'directed')
+ throw new Error(
+ 'graphology-communities-leiden: not yet implemented for directed graphs.'
+ );
+
+ // Attributes name
+ options = resolveDefaults(options, DEFAULTS);
+
+ // Empty graph case
+ var c = 0;
+
+ if (graph.size === 0) {
+ if (assign) {
+ graph.forEachNode(function (node) {
+ graph.setNodeAttribute(node, options.attributes.communities, c++);
+ });
+
+ return;
+ }
+
+ var communities = {};
+
+ graph.forEachNode(function (node) {
+ communities[node] = c++;
+ });
+
+ if (!detailed) return communities;
+
+ return {
+ communities: communities,
+ count: graph.order,
+ deltaComputations: 0,
+ dendrogram: null,
+ level: 0,
+ modularity: NaN,
+ moves: null,
+ nodesVisited: 0,
+ resolution: options.resolution
+ };
+ }
+
+ var fn = undirectedLeiden;
+
+ var results = fn(detailed, graph, options);
+
+ var index = results.index;
+
+ // Standard output
+ if (!detailed) {
+ if (assign) {
+ index.assign(options.attributes.community);
+ return;
+ }
+
+ return index.collect();
+ }
+
+ // Detailed output
+ var output = {
+ count: index.C,
+ deltaComputations: results.deltaComputations,
+ dendrogram: index.dendrogram,
+ level: index.level,
+ modularity: index.modularity(),
+ moves: results.moves,
+ nodesVisited: results.nodesVisited,
+ resolution: options.resolution
+ };
+
+ if (assign) {
+ index.assign(options.attributes.community);
+ return output;
+ }
+
+ output.communities = index.collect();
+
+ return output;
+}
+
+/**
+ * Exporting.
+ */
+var fn = leiden.bind(null, false, false);
+fn.assign = leiden.bind(null, true, false);
+fn.detailed = leiden.bind(null, false, true);
+fn.defaults = DEFAULTS;
+
+module.exports = fn;

package/vendor/leiden/utils.cjs

@@ -0,0 +1,392 @@
+/**
+ * Graphology Leiden Utils
+ * ========================
+ *
+ * Miscellaneous utilities used by the Leiden algorithm.
+ *
+ * Vendored from: https://github.com/graphology/graphology/tree/master/src/communities-leiden
+ * License: MIT
+ */
+var SparseMap = require('mnemonist/sparse-map');
+var createRandom = require('pandemonium/random').createRandom;
+
+function addWeightToCommunity(map, community, weight) {
+ var currentWeight = map.get(community);
+
+ if (typeof currentWeight === 'undefined') currentWeight = 0;
+
+ currentWeight += weight;
+
+ map.set(community, currentWeight);
+}
+
+function UndirectedLeidenAddenda(index, options) {
+ options = options || {};
+
+ var rng = options.rng || Math.random;
+ var randomness = 'randomness' in options ? options.randomness : 0.01;
+
+ this.index = index;
+ this.random = createRandom(rng);
+ this.randomness = randomness;
+ this.rng = rng;
+
+ var NodesPointerArray = index.counts.constructor;
+ var WeightsArray = index.weights.constructor;
+
+ var order = index.C;
+ this.resolution = index.resolution;
+
+ // Used to group nodes by communities
+ this.B = index.C;
+ this.C = 0;
+ this.communitiesOffsets = new NodesPointerArray(order);
+ this.nodesSortedByCommunities = new NodesPointerArray(order);
+ this.communitiesBounds = new NodesPointerArray(order + 1);
+
+ // Used to merge nodes subsets
+ this.communityWeights = new WeightsArray(order);
+ this.degrees = new WeightsArray(order);
+ this.nonSingleton = new Uint8Array(order);
+ this.externalEdgeWeightPerCommunity = new WeightsArray(order);
+ this.belongings = new NodesPointerArray(order);
+ this.neighboringCommunities = new SparseMap(WeightsArray, order);
+ this.cumulativeIncrement = new Float64Array(order);
+ this.macroCommunities = null;
+}
+
+UndirectedLeidenAddenda.prototype.groupByCommunities = function () {
+ var index = this.index;
+
+ var n, i, c, b, o;
+
+ n = 0;
+ o = 0;
+
+ for (i = 0; i < index.C; i++) {
+ c = index.counts[i];
+
+ if (c !== 0) {
+ this.communitiesBounds[o++] = n;
+ n += c;
+ this.communitiesOffsets[i] = n;
+ }
+ }
+
+ this.communitiesBounds[o] = n;
+
+ o = 0;
+
+ for (i = 0; i < index.C; i++) {
+ b = index.belongings[i];
+ o = --this.communitiesOffsets[b];
+ this.nodesSortedByCommunities[o] = i;
+ }
+
+ this.B = index.C - index.U;
+ this.C = index.C;
+};
+
+UndirectedLeidenAddenda.prototype.communities = function () {
+ var communities = new Array(this.B);
+
+ var i, j, community, start, stop;
+
+ for (i = 0; i < this.B; i++) {
+ start = this.communitiesBounds[i];
+ stop = this.communitiesBounds[i + 1];
+ community = [];
+
+ for (j = start; j < stop; j++) {
+ community.push(j);
+ }
+
+ communities[i] = community;
+ }
+
+ return communities;
+};
+
+UndirectedLeidenAddenda.prototype.mergeNodesSubset = function (start, stop) {
+ var index = this.index;
+ var currentMacroCommunity =
+ index.belongings[this.nodesSortedByCommunities[start]];
+ var neighboringCommunities = this.neighboringCommunities;
+
+ var totalNodeWeight = 0;
+
+ var i, j, w;
+ var ei, el, et;
+
+ // Initializing singletons
+ for (j = start; j < stop; j++) {
+ i = this.nodesSortedByCommunities[j];
+
+ this.belongings[i] = i;
+ this.nonSingleton[i] = 0;
+ this.degrees[i] = 0;
+ totalNodeWeight += index.loops[i] / 2;
+
+ this.communityWeights[i] = index.loops[i];
+ this.externalEdgeWeightPerCommunity[i] = 0;
+
+ ei = index.starts[i];
+ el = index.starts[i + 1];
+
+ for (; ei < el; ei++) {
+ et = index.neighborhood[ei];
+ w = index.weights[ei];
+
+ this.degrees[i] += w;
+
+ if (index.belongings[et] !== currentMacroCommunity) continue;
+
+ totalNodeWeight += w;
+ this.externalEdgeWeightPerCommunity[i] += w;
+ this.communityWeights[i] += w;
+ }
+ }
+
+ var microDegrees = this.externalEdgeWeightPerCommunity.slice();
+
+ var s, ri, ci;
+ var order = stop - start;
+
+ var degree,
+ bestCommunity,
+ qualityValueIncrement,
+ maxQualityValueIncrement,
+ totalTransformedQualityValueIncrement,
+ targetCommunity,
+ targetCommunityDegree,
+ targetCommunityWeight;
+
+ var r, lo, hi, mid, chosenCommunity;
+
+ ri = this.random(start, stop - 1);
+
+ for (s = start; s < stop; s++, ri++) {
+ j = start + (ri % order);
+
+ i = this.nodesSortedByCommunities[j];
+
+ if (this.nonSingleton[i] === 1) {
+ continue;
+ }
+
+ if (
+ this.externalEdgeWeightPerCommunity[i] <
+ this.communityWeights[i] *
+ (totalNodeWeight / 2 - this.communityWeights[i]) *
+ this.resolution
+ ) {
+ continue;
+ }
+
+ this.communityWeights[i] = 0;
+ this.externalEdgeWeightPerCommunity[i] = 0;
+
+ neighboringCommunities.clear();
+ neighboringCommunities.set(i, 0);
+
+ degree = 0;
+
+ ei = index.starts[i];
+ el = index.starts[i + 1];
+
+ for (; ei < el; ei++) {
+ et = index.neighborhood[ei];
+
+ if (index.belongings[et] !== currentMacroCommunity) continue;
+
+ w = index.weights[ei];
+
+ degree += w;
+
+ addWeightToCommunity(neighboringCommunities, this.belongings[et], w);
+ }
+
+ bestCommunity = i;
+ maxQualityValueIncrement = 0;
+ totalTransformedQualityValueIncrement = 0;
+
+ for (ci = 0; ci < neighboringCommunities.size; ci++) {
+ targetCommunity = neighboringCommunities.dense[ci];
+ targetCommunityDegree = neighboringCommunities.vals[ci];
+ targetCommunityWeight = this.communityWeights[targetCommunity];
+
+ if (
+ this.externalEdgeWeightPerCommunity[targetCommunity] >=
+ targetCommunityWeight *
+ (totalNodeWeight / 2 - targetCommunityWeight) *
+ this.resolution
+ ) {
+ qualityValueIncrement =
+ targetCommunityDegree -
+ ((degree + index.loops[i]) *
+ targetCommunityWeight *
+ this.resolution) /
+ totalNodeWeight;
+
+ if (qualityValueIncrement > maxQualityValueIncrement) {
+ bestCommunity = targetCommunity;
+ maxQualityValueIncrement = qualityValueIncrement;
+ }
+
+ if (qualityValueIncrement >= 0)
+ totalTransformedQualityValueIncrement += Math.exp(
+ qualityValueIncrement / this.randomness
+ );
+ }
+
+ this.cumulativeIncrement[ci] = totalTransformedQualityValueIncrement;
+ }
+
+ if (
+ totalTransformedQualityValueIncrement < Number.MAX_VALUE &&
+ totalTransformedQualityValueIncrement < Infinity
+ ) {
+ r = totalTransformedQualityValueIncrement * this.rng();
+ lo = -1;
+ hi = neighboringCommunities.size + 1;
+
+ while (lo < hi - 1) {
+ mid = (lo + hi) >>> 1;
+
+ if (this.cumulativeIncrement[mid] >= r) hi = mid;
+ else lo = mid;
+ }
+
+ chosenCommunity = neighboringCommunities.dense[hi];
+ } else {
+ chosenCommunity = bestCommunity;
+ }
+
+ this.communityWeights[chosenCommunity] += degree + index.loops[i];
+
+ ei = index.starts[i];
+ el = index.starts[i + 1];
+
+ for (; ei < el; ei++) {
+ et = index.neighborhood[ei];
+
+ if (index.belongings[et] !== currentMacroCommunity) continue;
+
+ targetCommunity = this.belongings[et];
+
+ if (targetCommunity === chosenCommunity) {
+ this.externalEdgeWeightPerCommunity[chosenCommunity] -=
+ microDegrees[et];
+ } else {
+ this.externalEdgeWeightPerCommunity[chosenCommunity] +=
+ microDegrees[et];
+ }
+ }
+
+ if (chosenCommunity !== i) {
+ this.belongings[i] = chosenCommunity;
+ this.nonSingleton[chosenCommunity] = 1;
+ this.C--;
+ }
+ }
+
+ var microCommunities = this.neighboringCommunities;
+ microCommunities.clear();
+
+ for (j = start; j < stop; j++) {
+ i = this.nodesSortedByCommunities[j];
+ microCommunities.set(this.belongings[i], 1);
+ }
+
+ return microCommunities.dense.slice(0, microCommunities.size);
+};
+
+UndirectedLeidenAddenda.prototype.refinePartition = function () {
+ this.groupByCommunities();
+
+ this.macroCommunities = new Array(this.B);
+
+ var i, start, stop, mapping;
+
+ var bounds = this.communitiesBounds;
+
+ for (i = 0; i < this.B; i++) {
+ start = bounds[i];
+ stop = bounds[i + 1];
+
+ mapping = this.mergeNodesSubset(start, stop);
+ this.macroCommunities[i] = mapping;
+ }
+};
+
+UndirectedLeidenAddenda.prototype.split = function () {
+ var index = this.index;
+ var isolates = this.neighboringCommunities;
+
+ isolates.clear();
+
+ var i, community, isolated;
+
+ for (i = 0; i < index.C; i++) {
+ community = this.belongings[i];
+
+ if (i !== community) continue;
+
+ isolated = index.isolate(i, this.degrees[i]);
+ isolates.set(community, isolated);
+ }
+
+ for (i = 0; i < index.C; i++) {
+ community = this.belongings[i];
+
+ if (i === community) continue;
+
+ isolated = isolates.get(community);
+ index.move(i, this.degrees[i], isolated);
+ }
+
+ var j, macro;
+
+ for (i = 0; i < this.macroCommunities.length; i++) {
+ macro = this.macroCommunities[i];
+
+ for (j = 0; j < macro.length; j++) macro[j] = isolates.get(macro[j]);
+ }
+};
+
+UndirectedLeidenAddenda.prototype.zoomOut = function () {
+ var index = this.index;
+ this.refinePartition();
+ this.split();
+
+ var newLabels = index.zoomOut();
+
+ var macro, leader, follower;
+
+ var i, j;
+
+ for (i = 0; i < this.macroCommunities.length; i++) {
+ macro = this.macroCommunities[i];
+ leader = newLabels[macro[0]];
+
+ for (j = 1; j < macro.length; j++) {
+ follower = newLabels[macro[j]];
+ index.expensiveMove(follower, leader);
+ }
+ }
+};
+
+UndirectedLeidenAddenda.prototype.onlySingletons = function () {
+ var index = this.index;
+
+ var i;
+
+ for (i = 0; i < index.C; i++) {
+ if (index.counts[i] > 1) return false;
+ }
+
+ return true;
+};
+
+exports.addWeightToCommunity = addWeightToCommunity;
+exports.UndirectedLeidenAddenda = UndirectedLeidenAddenda;