gthinking 1.3.0 → 2.1.1

package/tests/unit/validation.test.ts

@@ -0,0 +1,218 @@
+/**
+ * Unit Tests for Validation Utilities
+ */
+
+import {
+  sanitizeInput,
+  sanitizeForShell,
+  validateEmail,
+  isValidURL,
+  isNonEmptyString,
+  isPositiveInteger,
+  isInRange,
+  safeJsonParse,
+  safeJsonStringify,
+  validateSchema,
+  hasRequiredProperties,
+  isValidLength,
+  deepClone,
+  isPlainObject,
+} from '../../src/utils/validation';
+import { z } from 'zod';
+
+describe('sanitizeInput', () => {
+  it('should remove HTML tags', () => {
+    expect(sanitizeInput('<script>alert("xss")</script>')).toBe('scriptalert"xss"/script');
+  });
+
+  it('should remove shell metacharacters', () => {
+    expect(sanitizeInput('test; rm -rf /')).toBe('test rm -rf /');
+  });
+
+  it('should handle empty strings', () => {
+    expect(sanitizeInput('')).toBe('');
+  });
+
+  it('should trim whitespace', () => {
+    expect(sanitizeInput('  test  ')).toBe('test');
+  });
+});
+
+describe('sanitizeForShell', () => {
+  it('should remove dangerous characters', () => {
+    expect(sanitizeForShell('test; | & `')).toBe('test');
+  });
+
+  it('should allow safe characters', () => {
+    expect(sanitizeForShell('hello world_123')).toBe('hello world_123');
+  });
+});
+
+describe('validateEmail', () => {
+  it('should validate correct emails', () => {
+    expect(validateEmail('test@example.com')).toBe('test@example.com');
+    expect(validateEmail('user.name@domain.co.uk')).toBe('user.name@domain.co.uk');
+  });
+
+  it('should return null for invalid emails', () => {
+    expect(validateEmail('invalid')).toBeNull();
+    expect(validateEmail('@example.com')).toBeNull();
+    expect(validateEmail('test@')).toBeNull();
+  });
+});
+
+describe('isValidURL', () => {
+  it('should validate correct URLs', () => {
+    expect(isValidURL('https://example.com')).toBe(true);
+    expect(isValidURL('http://localhost:3000')).toBe(true);
+  });
+
+  it('should return false for invalid URLs', () => {
+    expect(isValidURL('not-a-url')).toBe(false);
+    expect(isValidURL('')).toBe(false);
+  });
+});
+
+describe('isNonEmptyString', () => {
+  it('should return true for non-empty strings', () => {
+    expect(isNonEmptyString('hello')).toBe(true);
+    expect(isNonEmptyString('a')).toBe(true);
+  });
+
+  it('should return false for empty or whitespace strings', () => {
+    expect(isNonEmptyString('')).toBe(false);
+    expect(isNonEmptyString('   ')).toBe(false);
+  });
+
+  it('should return false for non-strings', () => {
+    expect(isNonEmptyString(null)).toBe(false);
+    expect(isNonEmptyString(123)).toBe(false);
+    expect(isNonEmptyString(undefined)).toBe(false);
+  });
+});
+
+describe('isPositiveInteger', () => {
+  it('should return true for positive integers', () => {
+    expect(isPositiveInteger(1)).toBe(true);
+    expect(isPositiveInteger(100)).toBe(true);
+  });
+
+  it('should return false for non-positive integers', () => {
+    expect(isPositiveInteger(0)).toBe(false);
+    expect(isPositiveInteger(-1)).toBe(false);
+    expect(isPositiveInteger(1.5)).toBe(false);
+  });
+
+  it('should return false for non-numbers', () => {
+    expect(isPositiveInteger('1')).toBe(false);
+    expect(isPositiveInteger(null)).toBe(false);
+  });
+});
+
+describe('isInRange', () => {
+  it('should return true for values in range', () => {
+    expect(isInRange(5, 0, 10)).toBe(true);
+    expect(isInRange(0, 0, 10)).toBe(true);
+    expect(isInRange(10, 0, 10)).toBe(true);
+  });
+
+  it('should return false for values out of range', () => {
+    expect(isInRange(-1, 0, 10)).toBe(false);
+    expect(isInRange(11, 0, 10)).toBe(false);
+  });
+});
+
+describe('safeJsonParse', () => {
+  it('should parse valid JSON', () => {
+    const obj = { key: 'value' };
+    expect(safeJsonParse(JSON.stringify(obj))).toEqual(obj);
+  });
+
+  it('should return null for invalid JSON', () => {
+    expect(safeJsonParse('invalid json')).toBeNull();
+  });
+});
+
+describe('safeJsonStringify', () => {
+  it('should stringify valid objects', () => {
+    const obj = { key: 'value' };
+    expect(safeJsonStringify(obj)).toBe('{"key":"value"}');
+  });
+
+  it('should return null for circular references', () => {
+    const obj: Record<string, unknown> = { key: 'value' };
+    obj.circular = obj;
+    expect(safeJsonStringify(obj)).toBeNull();
+  });
+});
+
+describe('validateSchema', () => {
+  const TestSchema = z.object({
+    name: z.string(),
+    age: z.number().positive(),
+  });
+
+  it('should validate valid data', () => {
+    const data = { name: 'John', age: 30 };
+    expect(validateSchema(TestSchema, data)).toEqual(data);
+  });
+
+  it('should throw ValidationError for invalid data', () => {
+    const data = { name: 'John', age: -5 };
+    expect(() => validateSchema(TestSchema, data)).toThrow();
+  });
+});
+
+describe('hasRequiredProperties', () => {
+  it('should return true when all properties exist', () => {
+    const obj = { a: 1, b: 2, c: 3 };
+    expect(hasRequiredProperties(obj, ['a', 'b'])).toBe(true);
+  });
+
+  it('should return false when properties are missing', () => {
+    const obj: Record<string, any> = { a: 1 };
+    expect(hasRequiredProperties(obj, ['a', 'b'])).toBe(false);
+  });
+
+  it('should return false for undefined properties', () => {
+    const obj: Record<string, any> = { a: 1, b: undefined };
+    expect(hasRequiredProperties(obj, ['a', 'b'])).toBe(false);
+  });
+});
+
+describe('isValidLength', () => {
+  it('should return true for valid lengths', () => {
+    expect(isValidLength('hello', 1, 10)).toBe(true);
+    expect(isValidLength('a', 1, 10)).toBe(true);
+  });
+
+  it('should return false for invalid lengths', () => {
+    expect(isValidLength('', 1, 10)).toBe(false);
+    expect(isValidLength('hello world', 1, 5)).toBe(false);
+  });
+});
+
+describe('deepClone', () => {
+  it('should create a deep copy', () => {
+    const obj = { a: 1, b: { c: 2 } };
+    const clone = deepClone(obj);
+
+    expect(clone).toEqual(obj);
+    expect(clone).not.toBe(obj);
+    expect(clone.b).not.toBe(obj.b);
+  });
+});
+
+describe('isPlainObject', () => {
+  it('should return true for plain objects', () => {
+    expect(isPlainObject({})).toBe(true);
+    expect(isPlainObject({ a: 1 })).toBe(true);
+  });
+
+  it('should return false for non-plain objects', () => {
+    expect(isPlainObject([])).toBe(false);
+    expect(isPlainObject(null)).toBe(false);
+    expect(isPlainObject('string')).toBe(false);
+    expect(isPlainObject(123)).toBe(false);
+  });
+});

package/tsconfig.json

@@ -1,10 +1,10 @@
 {
   "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "lib": ["ES2020"],
+    "target": "ES2022",
+    "module": "CommonJS",
+    "lib": ["ES2022"],
     "outDir": "./dist",
-    "rootDir": ".",
+    "rootDir": "./src",
     "strict": true,
     "esModuleInterop": true,
     "skipLibCheck": true,
@@ -13,13 +13,18 @@
     "declarationMap": true,
     "sourceMap": true,
     "resolveJsonModule": true,
-    "moduleResolution": "node"
+    "moduleResolution": "node",
+    "noImplicitAny": true,
+    "strictNullChecks": false,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": false,
+    "noImplicitOverride": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false
   },
-  "include": [
-    "*.ts"
-  ],
-  "exclude": [
-    "node_modules",
-    "dist"
-  ]
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist", "tests"]
 }

package/GEMINI.md

@@ -1,68 +0,0 @@
-# Sequential Thinking System (gthinking)
-
-This project is a comprehensive intelligent thinking framework designed to perform complex problem solving, research, and analysis through a sequential process. It operates as a Model Context Protocol (MCP) server, allowing AI agents to leverage its capabilities.
-
-## Project Overview
-
-**Type:** TypeScript / Node.js Application (MCP Server)
-
-The system is architected as a "Modular Monolith" where a central `SequentialThinkingEngine` orchestrates various specialized modules (engines) to process queries. It simulates (or delegates to LLMs) cognitive processes like reasoning, planning, and creativity.
-
-### Key Components
-
-*   **`server.ts`**: The entry point for the MCP server. It exposes tools like `think`, `quick_search`, and `creative_solve`.
-*   **`engine.ts`**: The main orchestrator (`SequentialThinkingEngine`) that manages the flow of data between different thinking stages.
-*   **`llm-service.ts`**: A bridge service that executes local CLI commands (`gemini`, `claude`, `kimi`, `opencode`) to perform actual cognitive tasks (Reasoning, Analysis, Creativity) using external LLMs.
-*   **Modules:**
-    *   `search-discovery.ts`: Web search simulation and aggregation.
-    *   `analysis.ts`: Deep content analysis (Sentiment, Entities, Fact-checking).
-    *   `reasoning.ts`: Logical reasoning (Deductive, Inductive, Chain of Thought).
-    *   `creativity.ts`: Idea generation (Brainstorming, SCAMPER, Six Hats).
-    *   `planning.ts`: Task decomposition and project planning.
-    *   `learning.ts`: Context memory and knowledge graph management.
-
-## Building and Running
-
-### Prerequisites
-*   Node.js (>=16.0.0)
-*   TypeScript
-*   Local LLM CLIs installed (optional but recommended: `gemini`, `claude`, etc.)
-
-### Commands
-
-*   **Install Dependencies:**
-    ```bash
-    npm install
-    ```
-
-*   **Build Project:**
-    Compiles TypeScript to JavaScript in the `dist/` directory.
-    ```bash
-    npm run build
-    ```
-
-*   **Run Development Mode:**
-    Runs the examples using `ts-node`.
-    ```bash
-    npm run dev
-    ```
-
-*   **Run MCP Server:**
-    ```bash
-    node dist/server.js
-    ```
-    *Note: This is typically run by an MCP client (like Claude Desktop or Gemini CLI).*
-
-## Development Conventions
-
-*   **Architecture:** Follows a strict modular design. Each "Engine" (e.g., `ReasoningEngine`) should be self-contained in its own file and export a singleton instance.
-*   **Communication:** Modules communicate via standard TypeScript interfaces defined in `types.ts`. The main `engine.ts` handles the workflow.
-*   **LLM Integration:** Do not hardcode API calls in the modules. Use `llmService` from `llm-service.ts` to delegate complex tasks to the configured local LLM provider.
-*   **Error Handling:** Use the `ThinkingError` class for typed error handling within the thinking pipeline.
-
-## Configuration
-
-*   **LLM Provider:** The system automatically detects installed CLIs (`gemini`, `claude`). You can force a specific provider by setting the `LLM_PROVIDER` environment variable.
-    ```bash
-    export LLM_PROVIDER=claude
-    ```