gthinking 1.2.1 → 2.1.1

package/README.md

@@ -1,78 +1,104 @@
-# Sequential Thinking System
-
-ระบบ Sequential Thinking อัจฉริยะที่ครอบคลุมการคิดวิเคราะห์แบบหลายขั้นตอน สำหรับการแก้ปัญหาที่ซับซ้อน
-
-## Recent Updates (v1.2.1)
-*   **Security Fix:** ป้องกัน Command Injection Vulnerability ใน module `llm-service` โดยเปลี่ยนการทำงานจาก `exec` เป็น `spawn` เพื่อความปลอดภัยสูงสุด
-*   **Refactoring:** ปรับโครงสร้าง Codebase แยกไฟล์ `types.ts` ขนาดใหญ่เป็นโมดูลย่อย (`types/*`) เพื่อการบำรุงรักษาที่ดีขึ้น
-*   **Architecture:** เพิ่มการรองรับ **Dependency Injection** ใน `SequentialThinkingEngine` เพื่อความยืดหยุ่นและการทดสอบที่ง่ายขึ้น
-
-## คุณสมบัติหลัก
-
-### 1. Search & Discovery (ค้นหาและค้นพบ)
-- **Web Search แบบ Real-time**: ค้นหาข้อมูลจากหลายแหล่งพร้อมกัน
-- **Multi-source Aggregation**: รวมผลลัพธ์จากหลายแหล่งข้อมูล
-- **Intelligent Filtering**: กรองและจัดอันดับผลลัพธ์ตามความน่าเชื่อถือและความเกี่ยวข้อง
-- **Knowledge Base Integration**: เชื่อมต่อกับฐานความรู้ภายใน
-
-### 2. Analysis (การวิเคราะห์)
-- **Sentiment Analysis**: วิเคราะห์ความรู้สึกในเนื้อหา
-- **Entity Extraction**: แยกแยะบุคคล องค์กร สถานที่
-- **Topic Extraction**: ระบุหัวข้อหลัก
-- **Keyword Extraction**: สกัดคำสำคัญ
-- **Summarization**: สรุปเนื้อหา
-- **Fact Checking**: ตรวจสอบความถูกต้อง
-- **Comparison**: เปรียบเทียบข้อมูล
-
-### 3. Reasoning (การคิดเชิงตรรกะ)
-- **Chain of Thought**: โซ่แห่งการคิดแบบลึกซึ้ง
-- **Multiple Reasoning Types**: 
-  - Deductive (อนุมาน)
-  - Inductive (ตรรกยานุมาน)
-  - Abductive (อนุมานแบบพยากรณ์)
-  - Analogical (เปรียบเทียบ)
-  - Causal (เหตุและผล)
-  - Counterfactual (สมมติฐาน)
-- **Hypothesis Testing**: การตั้งสมมติฐานและพิสูจน์
-- **Problem Decomposition**: แยกปัญหาย่อย
-
-### 4. Learning (การเรียนรู้)
-- **Context Memory**: จดจำบริบทการสนทนา
-- **Pattern Recognition**: จดจำรูปแบบ
-- **Knowledge Graph**: กราฟความรู้ที่เชื่อมโยง
-- **User Preferences**: เรียนรู้ความชอบของผู้ใช้
-- **Feedback Integration**: ปรับปรุงจาก feedback
-
-### 5. Planning (การวางแผน)
-- **Task Decomposition**: แบ่งงานเป็นขั้นตอนย่อย
-- **Prioritization**: จัดลำดับความสำคัญ
-- **Resource Allocation**: จัดสรรทรัพยากร
-- **Progress Tracking**: ติดตามความคืบหน้า
-- **Risk Analysis**: วิเคราะห์ความเสี่ยง
-
-### 6. Creativity (การสร้างสรรค์)
-- **Brainstorming**: ระดมความคิด
-- **SCAMPER Technique**: เทคนิค SCAMPER
-- **Six Thinking Hats**: หมวก 6 ใบ
-- **Mind Mapping**: แผนที่ความคิด
-- **Out-of-Box Thinking**: คิดนอกกรอบ
-- **Concept Connection**: เชื่อมโยงแนวคิด
-
-## การติดตั้ง
+# gthinking v2.1.1
+
+Sequential Thinking System - Advanced multi-stage thinking engine with AI-powered analysis, reasoning, and planning
+
+## Overview
+
+`gthinking` is a comprehensive TypeScript library that implements a sequential thinking system designed to solve complex problems through multiple stages of analysis, reasoning, and synthesis. Version 2.1.1 brings critical security updates and a fully implemented Analysis Engine.
+
+## Features
+
+### Core Features
+- **Sequential Thinking Pipeline**: 8-stage thinking process (Search → Analysis → Reasoning → Learning → Planning → Creativity → Synthesis → Evaluation)
+- **Dynamic Pipeline**: Automatically selects appropriate stages based on query context
+- **Parallel Execution**: Supports parallel execution of independent stages
+- **Streaming Support**: Real-time results as each stage completes
+- **Caching Layer**: Intelligent caching to reduce redundant processing
+
+### Search & Discovery
+- Multi-provider web search (Google, Bing, Brave, DuckDuckGo)
+- Knowledge base integration
+- Intelligent result ranking and aggregation
+- Conflict detection and consensus scoring
+
+### Analysis
+- Sentiment analysis with emotion detection
+- Entity extraction (people, organizations, locations, etc.)
+- Topic extraction and keyword analysis
+- Text summarization
+- Fact checking
+- Language detection
+- Readability analysis
+
+### Reasoning
+- 6 types of reasoning: Deductive, Inductive, Abductive, Analogical, Causal, Counterfactual
+- Chain of Thought generation
+- Hypothesis management and testing
+- Problem decomposition
+
+### Planning
+- Task decomposition and prioritization
+- Resource allocation
+- Timeline generation with critical path analysis
+- Risk assessment and mitigation
+
+### Creativity
+- Brainstorming with multiple techniques
+- SCAMPER analysis
+- Six Thinking Hats
+- Mind mapping
+- Out-of-box thinking perspectives
+
+### Learning
+- Pattern recognition
+- Knowledge graph management
+- Context memory
+- User preference learning
+
+## Installation
 
 ```bash
-npm install sequential-thinking-system
+npm install gthinking
 ```
 
-## การใช้งานผ่าน npx (Recommended for MCP)
+## Quick Start
 
-วิธีที่ง่ายที่สุดในการใช้งานคือผ่าน **npx** โดยไม่ต้องติดตั้งลงเครื่อง เหมาะสำหรับนำไปเชื่อมต่อกับ **Gemini CLI** หรือ **Claude Desktop**
+### Basic Usage
 
-### การตั้งค่า MCP (Model Context Protocol)
+```typescript
+import { SequentialThinkingEngine } from 'gthinking';
+
+const engine = new SequentialThinkingEngine();
 
-เพิ่ม configuration นี้ลงในไฟล์ settings ของ MCP Client ของคุณ:
+const result = await engine.think({
+  query: 'How can we improve remote work productivity?',
+  preferredStages: ['search', 'analysis', 'reasoning', 'synthesis'],
+});
+
+console.log(result.summary);
+console.log(result.recommendations);
+```
 
-**สำหรับ Gemini CLI (`~/.gemini/config.json`) หรือ Claude Desktop:**
+### Using Individual Engines
+
+```typescript
+import { AnalysisEngine, ReasoningEngine } from 'gthinking';
+
+// Analysis
+const analysis = await AnalysisEngine.analyze({
+  content: 'Your text here...',
+  types: ['sentiment', 'entity', 'keyword'],
+});
+
+// Reasoning
+const reasoning = await ReasoningEngine.reason({
+  problem: 'Should we expand to Asian markets?',
+  type: 'deductive',
+  context: ['Current market saturation in US', 'Growing Asian economy'],
+});
+```
+
+### MCP Server Usage
 
 ```json
 {
@@ -81,241 +107,200 @@ npm install sequential-thinking-system
       "command": "npx",
       "args": ["-y", "gthinking"],
       "env": {
-        "LLM_PROVIDER": "gemini"
+        "LLM_PROVIDER": "gemini",
+        "LLM_API_KEY": "your-api-key"
       }
     }
   }
 }
 ```
 
-**Configuration Options:**
-*   `LLM_PROVIDER`: เลือก LLM ที่ติดตั้งในเครื่องเพื่อใช้ประมวลผล (รองรับ: `gemini`, `claude`, `kimi`, `opencode`) - ค่าเริ่มต้นคือ `gemini`
-
-### Gemini Instruction (Prompt)
+## CLI Mode (No API Key Required)
 
-เพื่อให้ Gemini เรียกใช้งานเครื่องมือได้อย่างมีประสิทธิภาพ แนะนำให้เพิ่ม Prompt นี้ใน System Instruction หรือตอนเริ่มสนทนา:
+`gthinking` v2.1.0 introduces **CLI Mode**, allowing you to use local CLI tools (like Gemini CLI, Claude CLI, or custom wrappers) directly without requiring an API key in the configuration. This is ideal for users who are already authenticated via OAuth in their terminal.
 
-> "You have access to a specialized thinking engine called 'gthinking'. Use the `think` tool for complex analysis, reasoning, and planning tasks. Use `creative_solve` for brainstorming and ideation. Use `quick_search` for fast information retrieval. When using `think`, consider the appropriate 'depth' and 'complexity' based on the user's request."
+### Configuration
 
-## การใช้งานเบื้องต้น (Code Library)
+Set the `GTHINKING_LLM_PROVIDER` to `cli` and specify your command.
 
-### 1. การคิดแบบพื้นฐาน
+#### 1. Gemini CLI (Smart Defaults)
+If you use the standard Gemini CLI, `gthinking` automatically configures the arguments for you.
 
-```typescript
-import { thinkingEngine } from 'sequential-thinking-system';
-
-const response = await thinkingEngine.think({
-  id: 'request_1',
-  query: 'What are the implications of AI in healthcare?'
-});
-
-console.log(response.finalAnswer);
-console.log(`Confidence: ${response.confidence}`);
+```bash
+export GTHINKING_LLM_PROVIDER=cli
+export GTHINKING_LLM_CLI_COMMAND=gemini
+# System will execute: gemini -p "your prompt"
 ```
 
-### 2. การค้นหาอย่างรวดเร็ว
-
-```typescript
-import { think } from 'sequential-thinking-system';
+#### 2. Other Tools (Generic)
+For tools that read from `stdin` (standard input):
 
-const answer = await think('Latest technology trends 2024');
-console.log(answer);
+```bash
+export GTHINKING_LLM_PROVIDER=cli
+export GTHINKING_LLM_CLI_COMMAND=opencode
+# System will execute: opencode << "your prompt"
 ```
 
-### 3. การวิเคราะห์เชิงลึก
+#### 3. Custom Arguments
+For tools requiring specific flags or arguments:
 
-```typescript
-import { analyze } from 'sequential-thinking-system';
-
-const analysis = await analyze(
-  'Climate change impact on agriculture',
-  'Focus on developing countries'
-);
-console.log(analysis);
+```bash
+export GTHINKING_LLM_PROVIDER=cli
+export GTHINKING_LLM_CLI_COMMAND=mytool
+export GTHINKING_LLM_CLI_ARGS="--fast,--json"
+export GTHINKING_LLM_CLI_PROMPT_METHOD=arg
+export GTHINKING_LLM_CLI_PROMPT_FLAG=--query
+# System will execute: mytool --fast --json --query "your prompt"
 ```
 
-### 4. การแก้ปัญหาเชิงสร้างสรรค์
-
-```typescript
-import { solveCreatively } from 'sequential-thinking-system';
+## Configuration
 
-const solution = await solveCreatively(
-  'How to reduce urban traffic congestion?'
-);
-console.log(solution);
-```
+### Environment Variables
 
-### 5. การสร้างแผน
+```bash
+# LLM Configuration
+GTHINKING_LLM_PROVIDER=gemini
+GTHINKING_LLM_API_KEY=your-api-key
+GTHINKING_LLM_MODEL=gemini-pro
 
-```typescript
-import { createPlan } from 'sequential-thinking-system';
+# Search Configuration
+GTHINKING_SEARCH_API_KEY=your-search-api-key
 
-const plan = await createPlan('Launch a mobile app');
-console.log(`Tasks: ${plan.tasks.length}`);
-console.log(`Estimated duration: ${plan.timeline.endDate}`);
+# Logging
+GTHINKING_LOG_LEVEL=info
 ```
 
-## การใช้งานขั้นสูง
-
-### กำหนดค่าการทำงาน
+### Programmatic Configuration
 
 ```typescript
-import { SequentialThinkingEngine } from 'sequential-thinking-system';
-
-const engine = new SequentialThinkingEngine({
-  maxSearchResults: 20,
-  analysisDepth: 'deep',
-  reasoningComplexity: 'complex',
-  learningEnabled: true,
-  creativityLevel: 'adventurous',
-  planningDetail: 'granular',
-  timeout: 120000
+import { SequentialThinkingEngine, ConfigManager } from 'gthinking';
+
+const config = new ConfigManager({
+  llm: {
+    provider: 'openai',
+    apiKey: 'your-api-key',
+    model: 'gpt-4',
+  },
+  search: {
+    providers: ['google', 'bing'],
+    maxResults: 20,
+  },
+  cache: {
+    enabled: true,
+    maxSize: 2000,
+  },
 });
 
-const response = await engine.think({
-  id: 'advanced_request',
-  query: 'Complex problem to solve',
-  preferredStages: [
-    'search',
-    'analysis', 
-    'reasoning',
-    'creativity',
-    'synthesis'
-  ]
-});
+const engine = new SequentialThinkingEngine(config.getConfig());
 ```
 
-### การใช้งานแต่ละโมดูลแยกต่างหาก
-
-```typescript
-import { 
-  searchEngine, 
-  analysisEngine, 
-  reasoningEngine,
-  learningEngine,
-  planningEngine,
-  creativityEngine 
-} from 'sequential-thinking-system';
-
-// Search
-const searchResults = await searchEngine.search('AI ethics', {
-  maxResults: 10,
-  sources: ['web', 'knowledge_base']
-});
+## API Reference
 
-// Analysis
-const analysis = await analysisEngine.analyze(content, {
-  types: ['sentiment', 'entity', 'topic'],
-  depth: 'deep'
-});
+### SequentialThinkingEngine
 
-// Reasoning
-const reasoning = await reasoningEngine.reason(problem, {
-  type: 'deductive',
-  maxSteps: 5
-});
+The main orchestrator class that coordinates all thinking stages.
 
-// Learning
-const context = learningEngine.getOrCreateContext('session_1');
-learningEngine.recordInteraction('session_1', query, response);
+#### Methods
 
-// Planning
-const plan = planningEngine.createPlan('Build a website', {
-  resources: [...],
-  deadline: new Date('2024-12-31')
-});
+- `think(request: ThinkingRequest): Promise<SynthesisResult>` - Execute full thinking pipeline
+- `quickSearch(query: string): Promise<SynthesisResult>` - Fast search with minimal stages
+- `deepAnalysis(query: string): Promise<SynthesisResult>` - Comprehensive analysis with all stages
+- `creativeSolve(challenge: string): Promise<CreativeResult>` - Creative problem solving
+- `createPlan(goal: string, options?: PlanningOptions): Promise<Plan>` - Generate execution plan
 
-// Creativity
-const session = creativityEngine.startSession('Improve user experience', {
-  techniques: ['brainstorming', 'scamper'],
-  ideaCount: 20
-});
-```
+### Individual Engines
 
-### การติดตามเหตุการณ์
+Each engine can be used independently:
 
-```typescript
-thinkingEngine.on('thinking_complete', (event) => {
-  console.log(`Completed in ${event.data.processingTime}ms`);
-});
+- `SearchDiscoveryEngine` - Web search and knowledge retrieval
+- `AnalysisEngine` - Content analysis
+- `ReasoningEngine` - Logical reasoning
+- `PlanningEngine` - Task planning
+- `CreativityEngine` - Creative thinking
+- `LearningEngine` - Pattern learning
+- `SynthesisEngine` - Result synthesis
 
-thinkingEngine.on('search_complete', (event) => {
-  console.log(`Found ${event.data.results.length} results`);
-});
+## Security
 
-thinkingEngine.on('analysis_complete', (event) => {
-  console.log(`Analysis confidence: ${event.data.confidence}`);
-});
-```
+Version 2.0.0 includes significant security improvements:
 
-## โครงสร้างโปรเจค
+- **Input Sanitization**: All user inputs are sanitized to prevent injection attacks
+- **Rate Limiting**: Built-in rate limiting to prevent abuse
+- **Safe LLM Calls**: HTTP API calls instead of shell commands
+- **Validation**: Comprehensive input validation using Zod schemas
 
-```
-sequential-thinking-system/
-├── types.ts           # Type definitions
-├── search-discovery.ts # Search module
-├── analysis.ts        # Analysis module
-├── reasoning.ts       # Reasoning module
-├── learning.ts        # Learning module
-├── planning.ts        # Planning module
-├── creativity.ts      # Creativity module
-├── engine.ts          # Main engine
-├── index.ts           # Exports
-└── README.md          # Documentation
-```
+## Performance
 
-## ตัวอย่าง Use Cases
+- **Caching**: Multi-level caching with TTL support
+- **Parallel Execution**: Independent stages run in parallel
+- **Streaming**: Real-time results without waiting for all stages
+- **Metrics**: Built-in performance metrics collection
 
-### 1. การวิจัยและรายงาน
+## Error Handling
 
 ```typescript
-const response = await thinkingEngine.deepAnalysis(
-  'Impact of remote work on productivity'
-);
-// ได้รับ: สรุปผลการวิจัย การวิเคราะห์ ข้อเสนอแนะ
+import { ThinkingError, TimeoutError, ValidationError } from 'gthinking';
+
+try {
+  const result = await engine.think({ query: '...' });
+} catch (error) {
+  if (error instanceof TimeoutError) {
+    console.log('Operation timed out:', error.stage);
+  } else if (error instanceof ValidationError) {
+    console.log('Validation failed:', error.details);
+  }
+}
 ```
 
-### 2. การวางแผนโครงการ
+## Testing
 
-```typescript
-const plan = await thinkingEngine.createPlan(
-  'Develop AI-powered chatbot',
-  {
-    resources: [developer, designer],
-    deadline: new Date('2024-06-01')
-  }
-);
-// ได้รับ: รายการงานย่อย ลำดับความสำคัญ ไทม์ไลน์
-```
+```bash
+# Run all tests
+npm test
 
-### 3. การแก้ปัญหาสร้างสรรค์
+# Run with coverage
+npm run test:coverage
 
-```typescript
-const solution = await thinkingEngine.creativeSolve(
-  'Increase customer engagement'
-);
-// ได้รับ: ไอเดียใหม่ๆ มุมมองที่แตกต่าง แนวทางปฏิบัติ
+# Run in watch mode
+npm run test:watch
 ```
 
-### 4. การตัดสินใจ
+## Contributing
 
-```typescript
-const response = await thinkingEngine.think({
-  query: 'Should we expand to Asian markets?',
-  preferredStages: ['search', 'analysis', 'reasoning'],
-  config: { reasoningComplexity: 'complex' }
-});
-// ได้รับ: การวิเคราะห์ การให้เหตุผล ข้อเสนอแนะ
-```
+1. Fork the repository
+2. Create a feature branch
+3. Make your changes
+4. Add tests
+5. Submit a pull request
+
+## License
+
+MIT License - see LICENSE file for details
 
-## สิทธิ์การใช้งาน
+## Changelog
 
-MIT License
+### v2.1.1
+- **Security Update**: Hardened input sanitization (`sanitizeForShell`) to strictly allow only alphanumeric and safe characters, preventing potential command injection.
+- **New Feature**: Fully implemented `AnalysisEngine` with support for Sentiment Analysis, Entity Extraction, Topic Extraction, Keyword Extraction, Summarization, and Readability metrics.
+- **Integration**: `SequentialThinkingEngine` now automatically initializes and uses `AnalysisEngine` for analysis tasks.
 
-## การมีส่วนร่วม
+### v2.1.0
+- **New Feature**: CLI Provider support! Connect `gthinking` to any local LLM CLI tool (Gemini, Claude, etc.).
+- Added `CLIProvider` for secure local process execution.
+- Added support for custom CLI arguments and prompt passing methods (Stdin/Arg).
+- Smart defaults for Gemini CLI integration.
 
-ยินดีรับ Pull Requests และ Issues
+### v2.0.0
+- Complete rewrite with improved architecture
+- Added security features (input sanitization, rate limiting)
+- Implemented caching layer
+- Added streaming support
+- Improved error handling
+- Added comprehensive test suite
+- Enhanced type safety
+- Added metrics collection
+- Improved LLM integration with HTTP APIs
 
-## ติดต่อ
+## Support
 
-For questions and support, please open an issue on GitHub.
+For issues and feature requests, please use the [GitHub issue tracker](https://github.com/gotza02/gthinking/issues).

package/dist/analysis/analysis-engine.d.ts

@@ -0,0 +1,63 @@
+/**
+ * Analysis Engine for gthinking v2.0.0
+ * AI-powered content analysis including sentiment, entities, topics, and more.
+ */
+import { EventEmitter } from 'events';
+import { LLMService } from '../llm/llm-service';
+import { CompleteAnalysisResult } from '../types';
+/**
+ * Analysis Engine
+ */
+export declare class AnalysisEngine extends EventEmitter {
+    private llmService;
+    constructor(llmService?: LLMService);
+    /**
+     * Set the LLM service
+     * @param llmService - The LLM service instance
+     */
+    setLLMService(llmService: LLMService): void;
+    /**
+     * Analyze content based on request
+     * @param request - The analysis request
+     * @returns Complete analysis result
+     */
+    analyze(request: unknown): Promise<CompleteAnalysisResult>;
+    /**
+     * Analyze sentiment
+     */
+    private analyzeSentiment;
+    /**
+     * Extract entities
+     */
+    private extractEntities;
+    /**
+     * Extract topics
+     */
+    private extractTopics;
+    /**
+     * Extract keywords
+     */
+    private extractKeywords;
+    /**
+     * Generate summary
+     */
+    private generateSummary;
+    /**
+     * Calculate readability metrics (Locally)
+     */
+    private analyzeReadability;
+    private countSyllables;
+    private countComplexWords;
+    private getGradeLevel;
+    /**
+     * Execute LLM analysis with retries and parsing
+     */
+    private executeLLMAnalysis;
+    private ensureLLM;
+    private calculateOverallConfidence;
+}
+/**
+ * Factory function
+ */
+export declare function createAnalysisEngine(llmService?: LLMService): AnalysisEngine;
+//# sourceMappingURL=analysis-engine.d.ts.map

package/dist/analysis/analysis-engine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analysis-engine.d.ts","sourceRoot":"","sources":["../../src/analysis/analysis-engine.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAEtC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAChD,OAAO,EAIL,sBAAsB,EASvB,MAAM,UAAU,CAAC;AAMlB;;GAEG;AACH,qBAAa,cAAe,SAAQ,YAAY;IAC9C,OAAO,CAAC,UAAU,CAA2B;gBAEjC,UAAU,CAAC,EAAE,UAAU;IAKnC;;;OAGG;IACI,aAAa,CAAC,UAAU,EAAE,UAAU,GAAG,IAAI;IAIlD;;;;OAIG;IACU,OAAO,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,sBAAsB,CAAC;IA4EvE;;OAEG;YACW,gBAAgB;IAiB9B;;OAEG;YACW,eAAe;IAmC7B;;OAEG;YACW,aAAa;IA+B3B;;OAEG;YACW,eAAe;IAgC7B;;OAEG;YACW,eAAe;IA0B7B;;OAEG;IACH,OAAO,CAAC,kBAAkB;IAmC1B,OAAO,CAAC,cAAc;IAKtB,OAAO,CAAC,iBAAiB;IAKzB,OAAO,CAAC,aAAa;IAQrB;;OAEG;YACW,kBAAkB;IAiBhC,OAAO,CAAC,SAAS;IAMjB,OAAO,CAAC,0BAA0B;CAUnC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,CAAC,EAAE,UAAU,GAAG,cAAc,CAE5E"}