@anh3d0nic/ice 1.0.0

package/src/index.ts

@@ -0,0 +1,40 @@
+/**
+ * ✦ ICE v4.3 — Qwen Code Termux
+ * Persistent AI Brain with Multi-Provider Support
+ * 
+ * By @anh3d0nic
+ * GitHub: github.com/anh3d0nic/qwen-code-termux-ice
+ */
+
+// Core engine
+export { ICEEngine } from './engine.js';
+
+// Intent decoding
+export { IntentDecoder } from './intent-decoder.js';
+
+// Multi-provider API client
+export { MultiProviderClient } from './multi-provider-client.js';
+export type { ProviderConfig, ChatMessage, ChatResponse } from './multi-provider-client.js';
+
+// D20 learning
+export { D20Learner } from './d20-learner.js';
+export type { LearningPattern, InteractionRecord } from './d20-learner.js';
+
+// Agent crews
+export { AgentCrews } from './agent-crews.js';
+export type { Agent, Crew } from './agent-crews.js';
+export { CrewType, AgentStatus } from './agent-crews.js';
+
+// Types
+export type {
+  IntentResult,
+  Entity,
+  ICEConfig,
+  ProcessingResult
+} from './types.js';
+
+export { IntentType } from './types.js';
+
+// Version info
+export const VERSION = '4.3.0-termux';
+export const AUTHOR = '@anh3d0nic';

package/src/intent-decoder.ts

@@ -0,0 +1,200 @@
+/**
+ * ICE v4.3 — Intent Decoder
+ * LLM-centric intent classification with few-shot learning
+ */
+
+import { MultiProviderClient, ChatMessage } from './multi-provider-client.js';
+import type { IntentResult } from './types.js';
+
+const DEFAULT_EXAMPLES = [
+  { user: 'What is Python?', intent: 'question', confidence: 0.95 },
+  { user: 'Write a function to sort', intent: 'code_request', confidence: 0.92 },
+  { user: 'Does stress cause illness?', intent: 'causal', confidence: 0.90 },
+  { user: 'How to install Docker?', intent: 'how_to', confidence: 0.93 },
+  { user: 'Compare MySQL vs PostgreSQL', intent: 'comparison', confidence: 0.91 },
+  { user: 'Calculate 15 * 3 + 24 / 4', intent: 'math_problem', confidence: 0.94 }
+];
+
+export class IntentDecoder {
+  private api: MultiProviderClient;
+  private examples: Array<{ user: string; intent: string; confidence: number }>;
+
+  constructor(api: MultiProviderClient) {
+    this.api = api;
+    this.examples = [...DEFAULT_EXAMPLES];
+  }
+
+  async decode(message: string, context?: string): Promise<IntentResult> {
+    const providers = this.api.getAvailableProviders();
+    
+    if (providers.length > 0) {
+      return await this._decodeAPI(message, context, providers[0]);
+    }
+    
+    return this._decodeFallback(message, context);
+  }
+
+  private async _decodeAPI(
+    message: string,
+    context: string | undefined,
+    provider: string
+  ): Promise<IntentResult> {
+    const examplesText = this.examples.slice(0, 5).map(
+      ex => `User: "${ex.user}" → Intent: ${ex.intent} (${(ex.confidence * 100).toFixed(0)}%)`
+    ).join('\n');
+
+    let prompt = `You are an intent classifier. Output ONLY JSON.
+
+Examples:
+${examplesText}
+
+Classify this:
+User: "${message}"
+
+Output JSON:
+{
+  "primary_intent": "one of: question, code_request, math_problem, causal, how_to, comparison, command, creative, opinion, unknown",
+  "secondary_intents": [],
+  "confidence": 0.0-1.0,
+  "entities": {"key": "value"},
+  "rephrased_request": "clear version",
+  "needs_clarification": true/false,
+  "clarifying_questions": ["list"] or null,
+  "reasoning": "brief explanation"
+}`;
+
+    if (context) {
+      prompt += `\nContext: ${context}`;
+    }
+
+    const messages: ChatMessage[] = [{ role: 'user', content: prompt }];
+    const response = await this.api.chat(messages, provider, undefined, 0.1, 500);
+
+    if (response?.content) {
+      try {
+        const jsonStart = response.content.indexOf('{');
+        const jsonEnd = response.content.lastIndexOf('}') + 1;
+        
+        if (jsonStart >= 0 && jsonEnd > jsonStart) {
+          const data = JSON.parse(response.content.slice(jsonStart, jsonEnd));
+          
+          if (data.confidence >= 0.8) {
+            this._storeExample(message, data);
+          }
+
+          return {
+            primary_intent: data.primary_intent || 'unknown',
+            secondary_intents: data.secondary_intents || [],
+            confidence: data.confidence || 0.5,
+            entities: data.entities || {},
+            rephrased_request: data.rephrased_request || message,
+            needs_clarification: data.needs_clarification || false,
+            clarifying_questions: data.clarifying_questions || null,
+            reasoning: data.reasoning || ''
+          };
+        }
+      } catch {
+        // Fall through to fallback
+      }
+    }
+
+    return this._decodeFallback(message, context);
+  }
+
+  private _decodeFallback(message: string, _context?: string): IntentResult {
+    const msgLower = message.toLowerCase();
+    const patterns: Record<string, string[]> = {
+      code_request: [
+        '\\b(write|create|build|code|function)\\b',
+        '\\b(python|javascript|java|react)\\b'
+      ],
+      question: [
+        '\\b(what|who|when|where|why|how)\\b.*\\b(\\?|is|are)\\b'
+      ],
+      causal: [
+        '\\b(cause|causes|effect|leads to)\\b',
+        '\\bwhy does\\b'
+      ],
+      how_to: [
+        '\\bhow (do|to|can)\\b',
+        '\\b(install|setup|configure)\\b'
+      ],
+      comparison: [
+        '\\b(compare|vs|versus|better)\\b'
+      ],
+      math_problem: [
+        '\\b(calculate|compute|solve)\\b',
+        '\\d+\\s*[\\+\\-\\*\\/]\\s*\\d+'
+      ]
+    };
+
+    const scores: Record<string, number> = {};
+    
+    for (const [intent, patternList] of Object.entries(patterns)) {
+      for (const pattern of patternList) {
+        if (new RegExp(pattern).test(msgLower)) {
+          scores[intent] = (scores[intent] || 0) + 0.3;
+        }
+      }
+    }
+
+    if (Object.keys(scores).length === 0) {
+      return {
+        primary_intent: 'unknown',
+        secondary_intents: [],
+        confidence: 0.3,
+        entities: {},
+        rephrased_request: message,
+        needs_clarification: true,
+        clarifying_questions: ['Could you clarify?'],
+        reasoning: 'No pattern matched'
+      };
+    }
+
+    const primary = Object.entries(scores).sort((a, b) => b[1] - a[1])[0][0];
+    const confidence = Math.min(0.9, scores[primary]);
+
+    return {
+      primary_intent: primary,
+      secondary_intents: [],
+      confidence,
+      entities: this._extractEntities(message),
+      rephrased_request: message,
+      needs_clarification: confidence < 0.7,
+      clarifying_questions: confidence < 0.7 ? ['Could you provide more details?'] : null,
+      reasoning: `Matched ${primary} pattern`
+    };
+  }
+
+  private _extractEntities(message: string): Record<string, string[]> {
+    const entities: Record<string, string[]> = {};
+
+    const techs = message.match(/\b(Python|JavaScript|Java|React|Docker|AWS|MySQL|PostgreSQL|MongoDB)\b/gi);
+    if (techs) entities.technologies = techs;
+
+    const nums = message.match(/\d+(?:\.\d+)?/g);
+    if (nums) entities.numbers = nums;
+
+    const times = message.match(/\b(today|tomorrow|yesterday|next week|last month)\b/gi);
+    if (times) entities.time = times;
+
+    return entities;
+  }
+
+  private _storeExample(message: string, data: Record<string, unknown>): void {
+    const confidence = (data.confidence as number) || 0;
+    if (confidence < 0.8) return;
+
+    const exists = this.examples.some(
+      ex => message.toLowerCase().includes(ex.user.toLowerCase())
+    );
+
+    if (!exists && this.examples.length < 50) {
+      this.examples.push({
+        user: message,
+        intent: (data.primary_intent as string) || 'unknown',
+        confidence
+      });
+    }
+  }
+}

package/src/multi-provider-client.ts

@@ -0,0 +1,200 @@
+/**
+ * ICE v4.3 — Multi-Provider API Client
+ * Supports: Groq, Gemini, Qwen OAuth
+ */
+
+import axios, { AxiosInstance } from 'axios';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+export interface ProviderConfig {
+  name: string;
+  apiKey?: string;
+  baseUrl: string;
+  models: {
+    primary: string;
+    fast: string;
+  };
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+export interface ChatResponse {
+  content: string;
+  model: string;
+  provider: string;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}
+
+export class MultiProviderClient {
+  private groqClient: AxiosInstance;
+  private geminiClient: AxiosInstance;
+  private providers: Map<string, ProviderConfig>;
+
+  constructor() {
+    this.providers = new Map([
+      ['groq', {
+        name: 'Groq',
+        apiKey: process.env.GROQ_API_KEY,
+        baseUrl: 'https://api.groq.com/openai/v1',
+        models: {
+          primary: 'qwen/qwen3-32b',
+          fast: 'llama-3.1-8b-instant'
+        }
+      }],
+      ['gemini', {
+        name: 'Gemini',
+        apiKey: process.env.GEMINI_API_KEY,
+        baseUrl: 'https://generativelanguage.googleapis.com/v1beta/models',
+        models: {
+          primary: 'gemini-2.0-flash',
+          fast: 'gemini-2.0-flash-lite'
+        }
+      }]
+    ]);
+
+    this.groqClient = axios.create({
+      baseURL: 'https://api.groq.com/openai/v1',
+      headers: {
+        'Authorization': `Bearer ${process.env.GROQ_API_KEY}`,
+        'Content-Type': 'application/json'
+      },
+      timeout: 30000
+    });
+
+    this.geminiClient = axios.create({
+      baseURL: 'https://generativelanguage.googleapis.com/v1beta/models',
+      timeout: 30000
+    });
+  }
+
+  isAvailable(provider: string): boolean {
+    const config = this.providers.get(provider);
+    return !!config?.apiKey;
+  }
+
+  getAvailableProviders(): string[] {
+    const available: string[] = [];
+    for (const [name, config] of this.providers.entries()) {
+      if (config.apiKey) {
+        available.push(name);
+      }
+    }
+    return available;
+  }
+
+  async chat(
+    messages: ChatMessage[],
+    provider: string = 'groq',
+    model?: string,
+    temperature: number = 0.4,
+    maxTokens: number = 2048
+  ): Promise<ChatResponse | null> {
+    if (!this.isAvailable(provider)) {
+      return null;
+    }
+
+    try {
+      if (provider === 'groq') {
+        return await this._groqChat(messages, model, temperature, maxTokens);
+      } else if (provider === 'gemini') {
+        return await this._geminiChat(messages, model, temperature, maxTokens);
+      }
+      return null;
+    } catch (error) {
+      console.error(`${provider} API Error:`, error instanceof Error ? error.message : error);
+      return null;
+    }
+  }
+
+  private async _groqChat(
+    messages: ChatMessage[],
+    model?: string,
+    temperature: number = 0.4,
+    maxTokens: number = 2048
+  ): Promise<ChatResponse> {
+    const config = this.providers.get('groq')!;
+    const response = await this.groqClient.post('/chat/completions', {
+      model: model || config.models.primary,
+      messages,
+      temperature,
+      max_tokens: maxTokens
+    });
+
+    const data = response.data;
+    return {
+      content: data.choices[0].message.content,
+      model: data.model,
+      provider: 'groq',
+      usage: {
+        promptTokens: data.usage?.prompt_tokens || 0,
+        completionTokens: data.usage?.completion_tokens || 0,
+        totalTokens: data.usage?.total_tokens || 0
+      }
+    };
+  }
+
+  private async _geminiChat(
+    messages: ChatMessage[],
+    model?: string,
+    temperature: number = 0.4,
+    maxTokens: number = 2048
+  ): Promise<ChatResponse> {
+    const config = this.providers.get('gemini')!;
+    const apiKey = config.apiKey;
+    const modelName = model || config.models.primary;
+
+    const geminiMessages = messages.map(msg => ({
+      role: msg.role === 'user' || msg.role === 'system' ? 'user' : 'model',
+      parts: [{ text: msg.content }]
+    }));
+
+    const response = await this.geminiClient.post(
+      `/${modelName}:generateContent?key=${apiKey}`,
+      {
+        contents: geminiMessages,
+        generationConfig: {
+          temperature,
+          maxOutputTokens: maxTokens
+        }
+      }
+    );
+
+    const data = response.data;
+    return {
+      content: data.candidates[0].content.parts[0].text,
+      model: modelName,
+      provider: 'gemini'
+    };
+  }
+
+  selectBestProvider(intent: string, complexity: string): string {
+    const available = this.getAvailableProviders();
+    if (available.length === 0) return 'fallback';
+
+    // Code tasks → Groq
+    if (intent === 'code_request') {
+      return available.includes('groq') ? 'groq' : available[0];
+    }
+
+    // Complex reasoning → Groq
+    if (complexity === 'complex' || complexity === 'critical') {
+      return available.includes('groq') ? 'groq' : available[0];
+    }
+
+    // Simple tasks → Fast provider
+    if (complexity === 'simple') {
+      return available.includes('gemini') ? 'gemini' : available[0];
+    }
+
+    return available[0];
+  }
+}

package/src/reasoning/chain-of-thought.ts

@@ -0,0 +1,166 @@
+/**
+ * ICE v4.3 — Chain of Thought Reasoning
+ * Step-by-step reasoning with confidence tracking
+ * 
+ * Based on: "Chain-of-Thought Prompting Elicits Reasoning in LLMs" (Wei et al.)
+ */
+
+import type { ReasoningStep, ReasoningConfig } from './types.js';
+
+const DEFAULT_CONFIG: ReasoningConfig = {
+  maxSteps: 10,
+  maxBranches: 3,
+  minConfidence: 0.7,
+  enableSelfConsistency: true,
+  enableCritique: true
+};
+
+export class ChainOfThought {
+  private steps: ReasoningStep[] = [];
+  private config: ReasoningConfig;
+
+  constructor(config?: Partial<ReasoningConfig>) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+
+  /**
+   * Reason through a problem step-by-step
+   */
+  async reason(problem: string, context?: string): Promise<ReasoningStep[]> {
+    this.steps = [];
+    
+    // Step 1: Understand the problem
+    this.addStep({
+      id: 1,
+      thought: `Understanding: ${problem}`,
+      confidence: 1.0,
+      evidence: context ? [context] : []
+    });
+
+    // Step 2: Break down into sub-problems
+    const subProblems = await this._decompose(problem);
+    this.addStep({
+      id: 2,
+      thought: `Decomposition: ${subProblems.length} sub-problems identified`,
+      confidence: 0.9,
+      evidence: subProblems
+    });
+
+    // Step 3: Solve each sub-problem
+    for (let i = 0; i < subProblems.length && this.steps.length < this.config.maxSteps; i++) {
+      const solution = await this._solveSubProblem(subProblems[i], context);
+      this.addStep({
+        id: this.steps.length + 1,
+        thought: `Solution ${i + 1}: ${solution}`,
+        confidence: 0.8,
+        evidence: [subProblems[i]]
+      });
+    }
+
+    // Step 4: Synthesize final answer
+    const synthesis = await this._synthesize(problem);
+    this.addStep({
+      id: this.steps.length + 1,
+      thought: `Synthesis: ${synthesis}`,
+      confidence: this._calculateFinalConfidence(),
+      evidence: this.steps.map(s => s.thought)
+    });
+
+    // Step 5: Self-consistency check (run multiple times)
+    if (this.config.enableSelfConsistency) {
+      const alternative = await this.reason(problem, context);
+      const consistency = this._checkConsistency(alternative);
+      this.addStep({
+        id: this.steps.length + 1,
+        thought: `Self-Consistency: ${consistency ? 'CONSISTENT' : 'INCONSISTENT'}`,
+        confidence: consistency ? 0.95 : 0.6
+      });
+    }
+
+    return this.steps;
+  }
+
+  private addStep(step: ReasoningStep): void {
+    this.steps.push(step);
+  }
+
+  private async _decompose(problem: string): Promise<string[]> {
+    // Decomposition heuristics
+    const subProblems: string[] = [];
+    
+    // Check for multiple questions
+    const questions = problem.match(/\?/g);
+    if (questions && questions.length > 1) {
+      const parts = problem.split(/[?.]/).filter(p => p.trim().length > 0);
+      subProblems.push(...parts.map(p => `${p.trim()}?`));
+    }
+    
+    // Check for compound tasks
+    if (problem.includes(' and ') || problem.includes(' then ')) {
+      const connectors = problem.split(/\s+(and|then)\s+/);
+      subProblems.push(...connectors.filter(c => c.length > 10));
+    }
+    
+    // Default: treat as single problem
+    if (subProblems.length === 0) {
+      subProblems.push(problem);
+    }
+    
+    return subProblems.slice(0, 5);
+  }
+
+  private async _solveSubProblem(subProblem: string, context?: string): Promise<string> {
+    // Simplified solver - in production would call LLM
+    return `Solved: ${subProblem.substring(0, 50)}...`;
+  }
+
+  private async _synthesize(problem: string): Promise<string> {
+    const evidence = this.steps.map(s => s.thought).join(' → ');
+    return `Based on: ${evidence.substring(0, 200)}...`;
+  }
+
+  private _calculateFinalConfidence(): number {
+    if (this.steps.length === 0) return 0.5;
+    
+    const confidences = this.steps.map(s => s.confidence);
+    const avg = confidences.reduce((a, b) => a + b, 0) / confidences.length;
+    
+    // Penalize long chains
+    const lengthPenalty = Math.max(0.8, 1 - (this.steps.length * 0.02));
+    
+    return Math.min(0.95, avg * lengthPenalty);
+  }
+
+  private _checkConsistency(alternative: ReasoningStep[]): boolean {
+    if (alternative.length === 0) return true;
+    
+    const finalStep = this.steps[this.steps.length - 1];
+    const altFinalStep = alternative[alternative.length - 1];
+    
+    // Check if conclusions are similar
+    const similarity = this._textSimilarity(finalStep.thought, altFinalStep.thought);
+    return similarity > 0.7;
+  }
+
+  private _textSimilarity(a: string, b: string): number {
+    const aWords = new Set(a.toLowerCase().split(/\s+/));
+    const bWords = new Set(b.toLowerCase().split(/\s+/));
+    
+    const intersection = [...aWords].filter(w => bWords.has(w)).length;
+    const union = new Set([...aWords, ...bWords]).size;
+    
+    return union > 0 ? intersection / union : 0;
+  }
+
+  getSteps(): ReasoningStep[] {
+    return this.steps;
+  }
+
+  getFinalConfidence(): number {
+    return this._calculateFinalConfidence();
+  }
+
+  reset(): void {
+    this.steps = [];
+  }
+}

package/src/reasoning/index.ts

@@ -0,0 +1,16 @@
+/**
+ * ICE v4.3 — Advanced Reasoning Module
+ * Scientific reasoning techniques for smarter AI
+ */
+
+export { ChainOfThought } from './chain-of-thought.js';
+export { TreeOfThoughts } from './tree-of-thoughts.js';
+export { SelfReflection } from './self-reflection.js';
+export { SocraticReviewer } from './socratic-reviewer.js';
+
+export type {
+  ReasoningStep,
+  ThoughtBranch,
+  ReflectionResult,
+  ReasoningConfig
+} from './types.js';