te.js 2.1.0 → 2.1.2

package/lib/llm/parse.js

@@ -0,0 +1,89 @@
+/**
+ * Parse JSON from LLM response text (handles markdown code blocks).
+ * Shared by auto-docs, error-inference, and other LLM features.
+ */
+
+/**
+ * Extract the first JSON object from a string.
+ * @param {string} str - Raw LLM response
+ * @returns {object|null}
+ */
+export function extractJSON(str) {
+  if (!str || typeof str !== 'string') return null;
+  const trimmed = str.trim();
+  const open = trimmed.indexOf('{');
+  if (open === -1) return null;
+  let depth = 0;
+  let end = -1;
+  for (let i = open; i < trimmed.length; i++) {
+    if (trimmed[i] === '{') depth++;
+    else if (trimmed[i] === '}') {
+      depth--;
+      if (depth === 0) {
+        end = i + 1;
+        break;
+      }
+    }
+  }
+  if (end === -1) return null;
+  try {
+    return JSON.parse(trimmed.slice(open, end));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Extract the first JSON array from a string.
+ * @param {string} str - Raw LLM response
+ * @returns {Array|null}
+ */
+export function extractJSONArray(str) {
+  if (!str || typeof str !== 'string') return null;
+  const trimmed = str.trim();
+  const open = trimmed.indexOf('[');
+  if (open === -1) return null;
+  let depth = 0;
+  let end = -1;
+  for (let i = open; i < trimmed.length; i++) {
+    if (trimmed[i] === '[') depth++;
+    else if (trimmed[i] === ']') {
+      depth--;
+      if (depth === 0) {
+        end = i + 1;
+        break;
+      }
+    }
+  }
+  if (end === -1) return null;
+  try {
+    return JSON.parse(trimmed.slice(open, end));
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Reconcile LLM-ordered tag names with actual tag objects. Returns tags in desired order;
+ * any tag not in orderedTagNames is appended at the end.
+ * @param {string[]} orderedTagNames - Tag names in desired order (from LLM)
+ * @param {Array<{ name: string, description?: string }>} tags - Current spec.tags
+ * @returns {Array<{ name: string, description?: string }>} Tags reordered
+ */
+export function reconcileOrderedTags(orderedTagNames, tags) {
+  if (!Array.isArray(tags) || !tags.length) return [];
+  if (!Array.isArray(orderedTagNames) || !orderedTagNames.length) return [...tags];
+  const byName = new Map(tags.map((t) => [t.name, t]));
+  const ordered = [];
+  for (const name of orderedTagNames) {
+    const tag = byName.get(name);
+    if (tag) {
+      ordered.push(tag);
+      byName.delete(name);
+    }
+  }
+  for (const [, tag] of byName) {
+    ordered.push(tag);
+  }
+  return ordered;
+}

package/package.json

@@ -1,62 +1,64 @@
-{
-  "name": "te.js",
-  "version": "2.1.0",
-  "description": "A nodejs framework",
-  "type": "module",
-  "main": "te.js",
-  "bin": {
-    "tejas": "cli/index.js"
-  },
-  "scripts": {
-    "start": "node te.js",
-    "test": "vitest",
-    "test:run": "vitest run",
-    "test:coverage": "vitest run --coverage",
-    "prepare": "husky"
-  },
-  "author": "Hirak",
-  "license": "ISC",
-  "devDependencies": {
-    "@types/node": "^20.12.5",
-    "husky": "^9.0.11",
-    "lint-staged": "^15.2.2",
-    "prettier": "3.2.5",
-    "vitest": "^4.0.18"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/hirakchhatbar/te.js.git"
-  },
-  "files": [
-    "te.js",
-    "cli",
-    "server",
-    "database",
-    "rate-limit",
-    "utils",
-    "auto-docs",
-    "README.md",
-    "docs"
-  ],
-  "dependencies": {
-    "ansi-colors": "^4.1.3",
-    "filesize": "^10.1.1",
-    "formidable": "^3.5.1",
-    "mime": "^4.0.1",
-    "statuses": "^2.0.1",
-    "tej-env": "^1.1.3",
-    "tej-logger": "^1.2.1"
-  },
-  "husky": {
-    "hooks": {
-      "pre-commit": "lint-staged",
-      "pre-push": "npm test"
-    }
-  },
-  "lint-staged": {
-    "src/**/*.{js,jsx}": [
-      "pretty-quick --staged",
-      "eslint --fix"
-    ]
-  }
-}
+{
+  "name": "te.js",
+  "version": "2.1.2",
+  "description": "AI Native Node.js Framework",
+  "type": "module",
+  "main": "te.js",
+  "bin": {
+    "tejas": "cli/index.js"
+  },
+  "scripts": {
+    "start": "node te.js",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "prepare": "husky"
+  },
+  "author": "Hirak",
+  "license": "ISC",
+  "devDependencies": {
+    "@types/node": "^20.12.5",
+    "husky": "^9.0.11",
+    "lint-staged": "^15.2.2",
+    "prettier": "3.2.5",
+    "vitest": "^4.0.18"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com/hirakchhatbar/te.js.git"
+  },
+  "files": [
+    "te.js",
+    "cli",
+    "cors",
+    "server",
+    "database",
+    "rate-limit",
+    "utils",
+    "lib",
+    "auto-docs",
+    "README.md",
+    "docs"
+  ],
+  "dependencies": {
+    "ansi-colors": "^4.1.3",
+    "filesize": "^10.1.1",
+    "formidable": "^3.5.1",
+    "mime": "^4.0.1",
+    "statuses": "^2.0.1",
+    "tej-env": "^1.1.3",
+    "tej-logger": "^1.2.1"
+  },
+  "husky": {
+    "hooks": {
+      "pre-commit": "lint-staged",
+      "pre-push": "npm test"
+    }
+  },
+  "lint-staged": {
+    "src/**/*.{js,jsx}": [
+      "pretty-quick --staged",
+      "eslint --fix"
+    ]
+  }
+}

package/rate-limit/algorithms/fixed-window.js

@@ -1,141 +1,141 @@
-import RateLimiter from '../base.js';
-import TejError from '../../server/error.js';
-
-/**
- * Fixed Window Rate Limiter Implementation
- *
- * @extends RateLimiter
- * @description
- * The fixed window algorithm uses discrete time windows to track and limit requests.
- * It's the simplest rate limiting approach, but can allow request spikes at window boundaries
- * when using rolling windows. This can be mitigated by using strict window alignment with
- * clock time.
- *
- * Key features:
- * - Simple to understand and implement
- * - Low memory usage (only stores counter and window start time)
- * - Optional strict window alignment with clock time
- * - Best for cases where precise spacing of requests is not critical
- *
- * Window types:
- * 1. Rolling windows: Start when first request arrives
- * 2. Strict windows: Align with clock time (e.g. every minute)
- *
- * @example
- * // Create a fixed window rate limiter with strict clock alignment
- * const limiter = new FixedWindowRateLimiter({
- *   maxRequests: 60,       // Allow 60 requests per minute
- *   timeWindowSeconds: 60,
- *   fixedWindow: {
- *     strictWindow: true   // Align windows with clock minutes
- *   }
- * });
- *
- * // Use in an API endpoint
- * async function handleRequest(ip) {
- *   const result = await limiter.consume(ip);
- *   if (!result.success) {
- *     throw new TejError(429, 'Rate limit exceeded');
- *   }
- *   // Process request...
- * }
- */
-class FixedWindowRateLimiter extends RateLimiter {
-  constructor(options) {
-    if (!options.fixedWindowConfig) {
-      options.fixedWindowConfig = {}; // Ensure defaults are set in base class
-    }
-    super(options);
-
-    if (!this.fixedWindowOptions) {
-      throw new TejError(
-        400,
-        'FixedWindowRateLimiter requires fixedWindowConfig options',
-      );
-    }
-  }
-
-  /**
-   * Check if a request should be allowed within the current window
-   *
-   * @param {string} identifier - Unique identifier for rate limiting (e.g., IP address, user ID)
-   * @returns {Promise<Object>} Rate limit check result
-   * @returns {boolean} result.success - Whether the request is allowed
-   * @returns {number} result.remainingRequests - Number of requests remaining in the window
-   * @returns {number} result.resetTime - Unix timestamp when the current window ends
-   */
-  async consume(identifier) {
-    const key = this.getKey(identifier);
-    const now = Date.now();
-    const options = this.getAlgorithmOptions('fixed-window');
-
-    // If using strict windows, align window start with clock
-    const windowStart = options.strictWindow
-      ? Math.floor(now / (this.options.timeWindowSeconds * 1000)) *
-        (this.options.timeWindowSeconds * 1000)
-      : now;
-
-    const stored = await this.storage.get(key);
-    if (!stored) {
-      await this.storage.set(
-        key,
-        {
-          counter: 1,
-          startTime: windowStart,
-        },
-        this.options.timeWindowSeconds,
-      );
-
-      return {
-        success: true,
-        remainingRequests: this.options.maxRequests - 1,
-        resetTime: Math.floor(
-          windowStart / 1000 + this.options.timeWindowSeconds,
-        ),
-      };
-    }
-
-    // If using strict windows, check if we need to start a new window
-    if (options.strictWindow && stored.startTime < windowStart) {
-      await this.storage.set(
-        key,
-        {
-          counter: 1,
-          startTime: windowStart,
-        },
-        this.options.timeWindowSeconds,
-      );
-
-      return {
-        success: true,
-        remainingRequests: this.options.maxRequests - 1,
-        resetTime: Math.floor(
-          windowStart / 1000 + this.options.timeWindowSeconds,
-        ),
-      };
-    }
-
-    if (stored.counter >= this.options.maxRequests) {
-      return {
-        success: false,
-        remainingRequests: 0,
-        resetTime: Math.floor(
-          stored.startTime / 1000 + this.options.timeWindowSeconds,
-        ),
-      };
-    }
-
-    stored.counter++;
-    await this.storage.set(key, stored, this.options.timeWindowSeconds);
-
-    return {
-      success: true,
-      remainingRequests: this.options.maxRequests - stored.counter,
-      resetTime: Math.floor(
-        stored.startTime / 1000 + this.options.timeWindowSeconds,
-      ),
-    };
-  }
-}
-
-export default FixedWindowRateLimiter;
+import RateLimiter from '../base.js';
+import TejError from '../../server/error.js';
+
+/**
+ * Fixed Window Rate Limiter Implementation
+ *
+ * @extends RateLimiter
+ * @description
+ * The fixed window algorithm uses discrete time windows to track and limit requests.
+ * It's the simplest rate limiting approach, but can allow request spikes at window boundaries
+ * when using rolling windows. This can be mitigated by using strict window alignment with
+ * clock time.
+ *
+ * Key features:
+ * - Simple to understand and implement
+ * - Low memory usage (only stores counter and window start time)
+ * - Optional strict window alignment with clock time
+ * - Best for cases where precise spacing of requests is not critical
+ *
+ * Window types:
+ * 1. Rolling windows: Start when first request arrives
+ * 2. Strict windows: Align with clock time (e.g. every minute)
+ *
+ * @example
+ * // Create a fixed window rate limiter with strict clock alignment
+ * const limiter = new FixedWindowRateLimiter({
+ *   maxRequests: 60,       // Allow 60 requests per minute
+ *   timeWindowSeconds: 60,
+ *   fixedWindow: {
+ *     strictWindow: true   // Align windows with clock minutes
+ *   }
+ * });
+ *
+ * // Use in an API endpoint
+ * async function handleRequest(ip) {
+ *   const result = await limiter.consume(ip);
+ *   if (!result.success) {
+ *     throw new TejError(429, 'Rate limit exceeded');
+ *   }
+ *   // Process request...
+ * }
+ */
+class FixedWindowRateLimiter extends RateLimiter {
+  constructor(options) {
+    if (!options.fixedWindowConfig) {
+      options.fixedWindowConfig = {}; // Ensure defaults are set in base class
+    }
+    super(options);
+
+    if (!this.fixedWindowOptions) {
+      throw new TejError(
+        400,
+        'FixedWindowRateLimiter requires fixedWindowConfig options',
+      );
+    }
+  }
+
+  /**
+   * Check if a request should be allowed within the current window
+   *
+   * @param {string} identifier - Unique identifier for rate limiting (e.g., IP address, user ID)
+   * @returns {Promise<Object>} Rate limit check result
+   * @returns {boolean} result.success - Whether the request is allowed
+   * @returns {number} result.remainingRequests - Number of requests remaining in the window
+   * @returns {number} result.resetTime - Unix timestamp when the current window ends
+   */
+  async consume(identifier) {
+    const key = this.getKey(identifier);
+    const now = Date.now();
+    const options = this.getAlgorithmOptions('fixed-window');
+
+    // If using strict windows, align window start with clock
+    const windowStart = options.strictWindow
+      ? Math.floor(now / (this.options.timeWindowSeconds * 1000)) *
+        (this.options.timeWindowSeconds * 1000)
+      : now;
+
+    const stored = await this.storage.get(key);
+    if (!stored) {
+      await this.storage.set(
+        key,
+        {
+          counter: 1,
+          startTime: windowStart,
+        },
+        this.options.timeWindowSeconds,
+      );
+
+      return {
+        success: true,
+        remainingRequests: this.options.maxRequests - 1,
+        resetTime: Math.floor(
+          windowStart / 1000 + this.options.timeWindowSeconds,
+        ),
+      };
+    }
+
+    // If using strict windows, check if we need to start a new window
+    if (options.strictWindow && stored.startTime < windowStart) {
+      await this.storage.set(
+        key,
+        {
+          counter: 1,
+          startTime: windowStart,
+        },
+        this.options.timeWindowSeconds,
+      );
+
+      return {
+        success: true,
+        remainingRequests: this.options.maxRequests - 1,
+        resetTime: Math.floor(
+          windowStart / 1000 + this.options.timeWindowSeconds,
+        ),
+      };
+    }
+
+    if (stored.counter >= this.options.maxRequests) {
+      return {
+        success: false,
+        remainingRequests: 0,
+        resetTime: Math.floor(
+          stored.startTime / 1000 + this.options.timeWindowSeconds,
+        ),
+      };
+    }
+
+    stored.counter++;
+    await this.storage.set(key, stored, this.options.timeWindowSeconds);
+
+    return {
+      success: true,
+      remainingRequests: this.options.maxRequests - stored.counter,
+      resetTime: Math.floor(
+        stored.startTime / 1000 + this.options.timeWindowSeconds,
+      ),
+    };
+  }
+}
+
+export default FixedWindowRateLimiter;