@anh3d0nic/ice 1.0.0

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@anh3d0nic/ice",
+  "version": "1.0.0",
+  "description": "Persistent AI Brain for Qwen Code Termux",
+  "type": "module",
+  "main": "src/index.js",
+  "types": "src/index.ts",
+  "bin": {
+    "ice": "src/cli.ts",
+    "ice-status": "src/status-cli.ts"
+  },
+  "scripts": {
+    "ice": "tsx src/cli.ts",
+    "status": "tsx src/status-cli.ts"
+  },
+  "keywords": [
+    "ice",
+    "termux",
+    "qwen",
+    "ai",
+    "code-assistant",
+    "android",
+    "groq",
+    "gemini"
+  ],
+  "author": "anh3d0nic",
+  "license": "MIT",
+  "dependencies": {
+    "axios": "^1.6.0",
+    "chalk": "^5.3.0",
+    "commander": "^11.1.0",
+    "dotenv": "^16.3.1",
+    "ora": "^7.0.1"
+  }
+}

package/src/agent-crews.ts

@@ -0,0 +1,189 @@
+/**
+ * ICE v4.3 — Agent Crews
+ * 102 specialized agents across 5 elite crews
+ */
+
+export enum CrewType {
+  ALPHA = 'alpha',
+  BETA = 'beta',
+  GAMMA = 'gamma',
+  DELTA = 'delta',
+  EPSILON = 'epsilon'
+}
+
+export enum AgentStatus {
+  IDLE = 'idle',
+  BUSY = 'busy',
+  ERROR = 'error'
+}
+
+export interface Agent {
+  id: string;
+  name: string;
+  role: string;
+  specialty: string;
+  crew: CrewType;
+  status: AgentStatus;
+  tasksCompleted: number;
+  successRate: number;
+}
+
+export interface Crew {
+  name: string;
+  type: CrewType;
+  agents: Agent[];
+  triggerKeywords: string[];
+  description: string;
+}
+
+export class AgentCrews {
+  private crews: Map<CrewType, Crew>;
+
+  constructor() {
+    this.crews = new Map();
+    this._initializeCrews();
+  }
+
+  private _initializeCrews(): void {
+    // Alpha Crew — Frontend & Infrastructure (A01-A20)
+    this.crews.set(CrewType.ALPHA, {
+      name: 'Alpha',
+      type: CrewType.ALPHA,
+      agents: this._createAgents(CrewType.ALPHA, 20, 'Frontend', 'UI/UX, databases, APIs, deployment'),
+      triggerKeywords: ['ui', 'frontend', 'html', 'css', 'react', 'vue', 'angular', 'database', 'sql', 'api', 'deploy', 'docker', 'aws'],
+      description: 'Frontend development, UI/UX, databases, APIs, and cloud deployment'
+    });
+
+    // Beta Crew — Code Quality & Security (B01-B20)
+    this.crews.set(CrewType.BETA, {
+      name: 'Beta',
+      type: CrewType.BETA,
+      agents: this._createAgents(CrewType.BETA, 20, 'Engineering', 'Code quality, testing, security, architecture'),
+      triggerKeywords: ['code', 'refactor', 'test', 'security', 'architecture', 'review', 'optimize', 'debug'],
+      description: 'Code quality, testing, security auditing, and system architecture'
+    });
+
+    // Gamma Crew — Android & Termux (G01-G20)
+    this.crews.set(CrewType.GAMMA, {
+      name: 'Gamma',
+      type: CrewType.GAMMA,
+      agents: this._createAgents(CrewType.GAMMA, 20, 'Android', 'Termux, Android, mobile development'),
+      triggerKeywords: ['termux', 'android', 'pkg', 'apk', 'mobile', 'path', 'permissions', 'apt'],
+      description: 'Android Termux environment, package management, and mobile development'
+    });
+
+    // Delta Crew — Orchestration & Memory (D01-D20)
+    this.crews.set(CrewType.DELTA, {
+      name: 'Delta',
+      type: CrewType.DELTA,
+      agents: this._createAgents(CrewType.DELTA, 20, 'Orchestration', 'Planning, routing, memory, learning'),
+      triggerKeywords: ['orchestrate', 'route', 'plan', 'coordinate', 'memory', 'learn', 'optimize'],
+      description: 'Task orchestration, routing, memory management, and meta-learning'
+    });
+
+    // Epsilon Crew — Tools & Infrastructure (E01-E20)
+    this.crews.set(CrewType.EPSILON, {
+      name: 'Epsilon',
+      type: CrewType.EPSILON,
+      agents: this._createAgents(CrewType.EPSILON, 20, 'Tools', 'Infrastructure, MCP, scaffolding'),
+      triggerKeywords: ['infra', 'tools', 'mcp', 'forge', 'scaffold', 'web', 'scrape', 'fetch'],
+      description: 'Infrastructure tools, MCP servers, project scaffolding, and web actions'
+    });
+  }
+
+  private _createAgents(crew: CrewType, count: number, role: string, specialty: string): Agent[] {
+    const agents: Agent[] = [];
+    const prefix = crew.charAt(0).toUpperCase() + crew.slice(1);
+    
+    for (let i = 1; i <= count; i++) {
+      agents.push({
+        id: `${crew}-${String(i).padStart(2, '0')}`,
+        name: `Agent ${prefix}-${i}`,
+        role,
+        specialty,
+        crew,
+        status: AgentStatus.IDLE,
+        tasksCompleted: 0,
+        successRate: 1.0
+      });
+    }
+    
+    return agents;
+  }
+
+  selectCrews(intent: string, entities: Record<string, unknown>): Crew[] {
+    const text = `${intent} ${JSON.stringify(entities)}`.toLowerCase();
+    const selected: Crew[] = [];
+
+    for (const crew of this.crews.values()) {
+      if (crew.triggerKeywords.some(kw => text.includes(kw))) {
+        selected.push(crew);
+      }
+    }
+
+    // Default to Delta (orchestration) if none match
+    if (selected.length === 0) {
+      selected.push(this.crews.get(CrewType.DELTA)!);
+    }
+
+    return selected;
+  }
+
+  getCrew(type: CrewType): Crew | undefined {
+    return this.crews.get(type);
+  }
+
+  getAllCrews(): Crew[] {
+    return Array.from(this.crews.values());
+  }
+
+  getAgent(agentId: string): Agent | undefined {
+    for (const crew of this.crews.values()) {
+      const agent = crew.agents.find(a => a.id === agentId);
+      if (agent) return agent;
+    }
+    return undefined;
+  }
+
+  getTotalAgents(): number {
+    let total = 0;
+    for (const crew of this.crews.values()) {
+      total += crew.agents.length;
+    }
+    return total;
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      crews: this.crews.size,
+      totalAgents: this.getTotalAgents(),
+      crewNames: Array.from(this.crews.values()).map(c => c.name),
+      agentCrews: Object.fromEntries(
+        Array.from(this.crews.entries()).map(([type, crew]) => [type, crew.agents.length])
+      )
+    };
+  }
+
+  assignTask(agentId: string): boolean {
+    const agent = this.getAgent(agentId);
+    if (!agent) return false;
+    
+    agent.status = AgentStatus.BUSY;
+    return true;
+  }
+
+  completeTask(agentId: string, success: boolean): boolean {
+    const agent = this.getAgent(agentId);
+    if (!agent) return false;
+    
+    agent.status = AgentStatus.IDLE;
+    agent.tasksCompleted++;
+    
+    // Update success rate
+    const totalTasks = agent.tasksCompleted;
+    const successfulTasks = success ? totalTasks : totalTasks - 1;
+    agent.successRate = successfulTasks / totalTasks;
+    
+    return true;
+  }
+}

package/src/cli.ts

@@ -0,0 +1,96 @@
+#!/usr/bin/env node
+/**
+ * ICE v4.3 — CLI Command
+ * Main interactive CLI for ICE
+ */
+
+import { ICEEngine } from './engine.js';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import ora from 'ora';
+
+const program = new Command();
+
+program
+  .name('ice')
+  .description('✦ ICE v4.3 — Interactive AI Assistant')
+  .version('4.3.0-termux')
+  .option('-v, --verbose', 'Enable verbose output')
+  .option('-j, --json', 'Output in JSON format')
+  .action(async (options) => {
+    const engine = new ICEEngine();
+    
+    console.log(chalk.blue.bold('\n✦ ICE v4.3 — Qwen Code Termux'));
+    console.log(chalk.blue('by @anh3d0nic'));
+    console.log(chalk.gray('Type "exit" to quit\n'));
+
+    const status = engine.getStatus();
+    console.log(chalk.green('✓'), `Version: ${status.version}`);
+    console.log(chalk.green('✓'), `User: ${status.user}`);
+    console.log(chalk.green('✓'), `Providers: ${(status.providers as string[]).join(', ') || 'None (fallback mode)'}`);
+    console.log(chalk.green('✓'), `Crews: ${(status.crews as Record<string, unknown>).crews} (${(status.crews as Record<string, unknown>).totalAgents} agents)`);
+    console.log();
+
+    const readline = await import('readline');
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+
+    const prompt = () => {
+      rl.question(chalk.cyan.bold('You: '), async (message) => {
+        if (message.toLowerCase() === 'exit' || message.toLowerCase() === 'quit') {
+          console.log(chalk.blue('\nGoodbye!\n'));
+          rl.close();
+          return;
+        }
+
+        if (message.toLowerCase() === 'status') {
+          console.log(chalk.yellow('\n[ICE STATUS]'));
+          console.log(JSON.stringify(engine.getStatus(), null, 2));
+          console.log();
+          prompt();
+          return;
+        }
+
+        const spinner = ora('ICE thinking...').start();
+        
+        try {
+          const result = await engine.process(message);
+          spinner.stop();
+
+          if (options.json) {
+            console.log(JSON.stringify(result, null, 2));
+          } else {
+            console.log(chalk.yellow('\n[ICE THINKING]'));
+            console.log(chalk.gray(`  Intent: ${result.intent.primary_intent}`));
+            console.log(chalk.gray(`  Confidence: ${(result.intent.confidence * 100).toFixed(0)}%`));
+            console.log(chalk.gray(`  Complexity: ${result.complexity}`));
+            console.log(chalk.gray(`  Crews: ${result.crews.join(', ')}`));
+            console.log(chalk.gray(`  Provider: ${result.provider}`));
+            console.log(chalk.gray(`  Time: ${result.time.toFixed(3)}s`));
+            
+            console.log(chalk.cyan('\n[RESPONSE]'));
+            console.log(result.response);
+            
+            if (result.intent.needs_clarification && result.intent.clarifying_questions) {
+              console.log(chalk.yellow('\n[CLARIFICATION NEEDED]'));
+              for (const question of result.intent.clarifying_questions) {
+                console.log(chalk.gray(`  - ${question}`));
+              }
+            }
+          }
+        } catch (error) {
+          spinner.stop();
+          console.error(chalk.red('Error:'), error instanceof Error ? error.message : error);
+        }
+
+        console.log();
+        prompt();
+      });
+    };
+
+    prompt();
+  });
+
+program.parse();

package/src/d20-learner.ts

@@ -0,0 +1,161 @@
+/**
+ * ICE v4.3 — D20 Learner
+ * Pattern learning and storage with user isolation
+ */
+
+import fs from 'fs/promises';
+import path from 'path';
+import os from 'os';
+
+export interface LearningPattern {
+  id: string;
+  type: 'routing' | 'reasoning' | 'optimization';
+  intent: string;
+  successCount: number;
+  totalCount: number;
+  avgTime: number;
+  provider: string;
+  lastUsed: number;
+}
+
+export interface InteractionRecord {
+  input: string;
+  intent: string;
+  complexity: string;
+  crews: string[];
+  provider: string;
+  model: string;
+  responseTime: number;
+  timestamp: number;
+}
+
+export class D20Learner {
+  private patterns: Map<string, LearningPattern>;
+  private memory: InteractionRecord[];
+  private storagePath: string;
+  private currentUser: string;
+
+  constructor() {
+    this.currentUser = process.env.ICE_USER_ID || process.env.USER || os.userInfo().username || 'default';
+    this.storagePath = path.join(os.homedir(), '.qwen', 'ice-memory', this.currentUser);
+    this.patterns = new Map();
+    this.memory = [];
+    this._initialize();
+  }
+
+  private async _initialize(): Promise<void> {
+    try {
+      await fs.mkdir(this.storagePath, { recursive: true, mode: 0o700 });
+      await this._loadPatterns();
+      await this._loadMemory();
+    } catch (error) {
+      console.error('[D20] Initialization error:', error instanceof Error ? error.message : error);
+    }
+  }
+
+  private async _loadPatterns(): Promise<void> {
+    try {
+      const patternsFile = path.join(this.storagePath, `${this.currentUser}_patterns.json`);
+      const data = await fs.readFile(patternsFile, 'utf-8');
+      const patternsData = JSON.parse(data);
+      
+      for (const [key, pattern] of Object.entries(patternsData)) {
+        this.patterns.set(key, pattern as LearningPattern);
+      }
+    } catch {
+      // Start fresh if file doesn't exist
+    }
+  }
+
+  private async _loadMemory(): Promise<void> {
+    try {
+      const memoryFile = path.join(this.storagePath, `${this.currentUser}_memory.json`);
+      const data = await fs.readFile(memoryFile, 'utf-8');
+      this.memory = JSON.parse(data);
+    } catch {
+      // Start fresh if file doesn't exist
+    }
+  }
+
+  private async _savePatterns(): Promise<void> {
+    try {
+      const patternsFile = path.join(this.storagePath, `${this.currentUser}_patterns.json`);
+      const patternsData = Object.fromEntries(this.patterns);
+      await fs.writeFile(patternsFile, JSON.stringify(patternsData, null, 2), { mode: 0o600 });
+    } catch (error) {
+      console.error('[D20] Save patterns error:', error instanceof Error ? error.message : error);
+    }
+  }
+
+  private async _saveMemory(): Promise<void> {
+    try {
+      const memoryFile = path.join(this.storagePath, `${this.currentUser}_memory.json`);
+      await fs.writeFile(memoryFile, JSON.stringify(this.memory.slice(-100), null, 2), { mode: 0o600 });
+    } catch (error) {
+      console.error('[D20] Save memory error:', error instanceof Error ? error.message : error);
+    }
+  }
+
+  async learn(intent: string, success: boolean, responseTime: number, provider: string): Promise<void> {
+    const pattern = this.patterns.get(intent) || {
+      id: intent,
+      type: 'routing' as const,
+      intent,
+      successCount: 0,
+      totalCount: 0,
+      avgTime: 0,
+      provider,
+      lastUsed: Date.now()
+    };
+
+    pattern.totalCount++;
+    if (success) {
+      pattern.successCount++;
+    }
+
+    // Update average time
+    pattern.avgTime = ((pattern.avgTime * (pattern.totalCount - 1)) + responseTime) / pattern.totalCount;
+    pattern.provider = provider;
+    pattern.lastUsed = Date.now();
+
+    this.patterns.set(intent, pattern);
+    await this._savePatterns();
+  }
+
+  async store(interaction: InteractionRecord): Promise<void> {
+    this.memory.push({
+      ...interaction,
+      timestamp: Date.now()
+    });
+    await this._saveMemory();
+  }
+
+  getPattern(intent: string): LearningPattern | undefined {
+    return this.patterns.get(intent);
+  }
+
+  getPatterns(): LearningPattern[] {
+    return Array.from(this.patterns.values());
+  }
+
+  getMemory(limit: number = 100): InteractionRecord[] {
+    return this.memory.slice(-limit);
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      patternsCount: this.patterns.size,
+      memorySize: this.memory.length,
+      routingPatterns: Array.from(this.patterns.values()).filter(p => p.type === 'routing').length,
+      user: this.currentUser,
+      storagePath: this.storagePath
+    };
+  }
+
+  async clear(): Promise<void> {
+    this.patterns.clear();
+    this.memory = [];
+    await this._savePatterns();
+    await this._saveMemory();
+  }
+}

package/src/engine.ts

@@ -0,0 +1,219 @@
+/**
+ * ICE v4.3 — Main Engine (With Scientific Reasoning)
+ * Orchestrates intent decoding, reasoning, and response generation
+ */
+
+import { MultiProviderClient } from './multi-provider-client.js';
+import { IntentDecoder } from './intent-decoder.js';
+import { D20Learner } from './d20-learner.js';
+import { AgentCrews } from './agent-crews.js';
+import { ChainOfThought } from './reasoning/chain-of-thought.js';
+import { TreeOfThoughts } from './reasoning/tree-of-thoughts.js';
+import { SelfReflection } from './reasoning/self-reflection.js';
+import { SocraticReviewer } from './reasoning/socratic-reviewer.js';
+import type { IntentResult, ProcessingResult, ICEConfig } from './types.js';
+import os from 'os';
+
+const DEFAULT_CONFIG: ICEConfig = {
+  storagePath: os.homedir() + '/.qwen',
+  memoryPath: os.homedir() + '/.qwen/ice-memory',
+  models: {
+    groq_primary: 'qwen/qwen3-32b',
+    groq_fast: 'llama-3.1-8b-instant',
+    gemini: 'gemini-2.0-flash'
+  },
+  temperature: 0.4,
+  maxTokens: 2048,
+  timeout: 30000
+};
+
+export class ICEEngine {
+  private api: MultiProviderClient;
+  private intentDecoder: IntentDecoder;
+  private d20: D20Learner;
+  private crews: AgentCrews;
+  private cot: ChainOfThought;
+  private tot: TreeOfThoughts;
+  private reflection: SelfReflection;
+  private socratic: SocraticReviewer;
+  private config: ICEConfig;
+  private startTime: number;
+  private currentUser: string;
+
+  constructor(config?: Partial<ICEConfig>) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+    this.api = new MultiProviderClient();
+    this.intentDecoder = new IntentDecoder(this.api);
+    this.d20 = new D20Learner();
+    this.crews = new AgentCrews();
+    this.cot = new ChainOfThought();
+    this.tot = new TreeOfThoughts();
+    this.reflection = new SelfReflection();
+    this.socratic = new SocraticReviewer();
+    this.startTime = Date.now();
+    this.currentUser = process.env.ICE_USER_ID || process.env.USER || os.userInfo().username || 'default';
+  }
+
+  async process(message: string, context?: string): Promise<ProcessingResult> {
+    const start = Date.now();
+
+    // Step 1: Decode intent
+    const intent = await this.intentDecoder.decode(message, context);
+
+    // Step 2: Assess complexity and select reasoning mode
+    const complexity = this._assessComplexity(intent);
+    const reasoningMode = this._selectReasoningMode(complexity, intent);
+
+    // Step 3: Apply scientific reasoning based on mode
+    let enhancedContext = context || '';
+    if (reasoningMode === 'cot') {
+      const steps = await this.cot.reason(message, context);
+      enhancedContext += `\n\n[Chain of Thought: ${steps.length} steps, confidence: ${(this.cot.getFinalConfidence() * 100).toFixed(0)}%]`;
+    } else if (reasoningMode === 'tot') {
+      const branch = await this.tot.explore(message, context);
+      enhancedContext += `\n\n[Tree of Thoughts: ${this.tot.getBranches().length} branches, best score: ${(branch.score * 100).toFixed(0)}%]`;
+    }
+
+    // Step 4: Select crews
+    const crews = this.crews.selectCrews(intent.primary_intent, intent.entities);
+
+    // Step 5: Select provider
+    const provider = this.api.selectBestProvider(intent.primary_intent, complexity);
+    const model = this._getModelForProvider(provider, intent.primary_intent);
+
+    // Step 6: Generate response with reasoning context
+    const response = await this._generateResponse(message, intent, provider, model, enhancedContext);
+
+    // Step 7: Self-reflection (critique before delivery)
+    const reflection = await this.reflection.reflect(message, response, enhancedContext);
+    const finalResponse = reflection.confidenceGain > 0.05 ? reflection.revisedAnswer : response;
+
+    const elapsed = (Date.now() - start) / 1000;
+
+    // Step 8: Learn from this interaction
+    await this.d20.learn(intent.primary_intent, true, elapsed, provider);
+    await this.d20.store({
+      input: message,
+      intent: intent.primary_intent,
+      complexity,
+      crews: crews.map(c => c.name),
+      provider,
+      model,
+      responseTime: elapsed
+    });
+
+    return {
+      intent,
+      complexity,
+      crews: crews.map(c => c.name),
+      provider,
+      model,
+      response: finalResponse,
+      time: elapsed,
+      user: this.currentUser,
+      reasoning: {
+        mode: reasoningMode,
+        reflectionApplied: reflection.confidenceGain > 0.05,
+        confidenceGain: reflection.confidenceGain
+      }
+    };
+  }
+
+  private _assessComplexity(intent: IntentResult): string {
+    if (intent.confidence < 0.5) return 'complex';
+    if (['code_request', 'math_problem', 'causal'].includes(intent.primary_intent)) return 'moderate';
+    if (intent.secondary_intents.length > 2) return 'moderate';
+    return 'simple';
+  }
+
+  private _selectReasoningMode(complexity: string, intent: IntentResult): 'cot' | 'tot' | 'direct' {
+    // Use Chain of Thought for moderate complexity
+    if (complexity === 'moderate') return 'cot';
+    
+    // Use Tree of Thoughts for complex problems
+    if (complexity === 'complex') return 'tot';
+    
+    // Direct for simple queries
+    return 'direct';
+  }
+
+  private _getModelForProvider(provider: string, intent: string): string {
+    if (provider === 'groq') {
+      return intent === 'code_request' 
+        ? this.config.models.groq_primary 
+        : this.config.models.groq_fast;
+    }
+    return this.config.models.gemini;
+  }
+
+  private async _generateResponse(
+    message: string,
+    intent: IntentResult,
+    provider: string,
+    model: string,
+    context: string
+  ): Promise<string> {
+    if (!this.api.isAvailable(provider)) {
+      return this._fallbackResponse(message, intent);
+    }
+
+    const prompt = `You are ICE v4.3 by @anh3d0nic. Think first, then respond.
+
+[ICE THINKING]
+Intent: ${intent.primary_intent}
+Entities: ${JSON.stringify(intent.entities)}
+Confidence: ${(intent.confidence * 100).toFixed(0)}%
+Needs Clarification: ${intent.needs_clarification}
+${context ? `\nReasoning Context: ${context}` : ''}
+
+[RESPONSE]
+User request: ${message}
+
+Here's my response:
+`;
+
+    const response = await this.api.chat(
+      [{ role: 'user', content: prompt }],
+      provider,
+      model,
+      this.config.temperature,
+      this.config.maxTokens
+    );
+
+    return response?.content || this._fallbackResponse(message, intent);
+  }
+
+  private _fallbackResponse(message: string, intent: IntentResult): string {
+    if (intent.needs_clarification) {
+      const questions = this.socratic.generateQuestions(message);
+      return `I need more information. ${questions[0]?.question || 'Could you clarify your request?'}`;
+    }
+    return `[Fallback] You asked about ${intent.primary_intent}: ${message}`;
+  }
+
+  getStatus(): Record<string, unknown> {
+    return {
+      version: '4.3.0-termux',
+      user: this.currentUser,
+      memoryDir: this.config.memoryPath + '/' + this.currentUser,
+      providers: this.api.getAvailableProviders(),
+      providerStatus: {
+        groq: this.api.isAvailable('groq'),
+        gemini: this.api.isAvailable('gemini')
+      },
+      uptime: Math.round((Date.now() - this.startTime) / 1000),
+      reasoning: {
+        chainOfThought: 'available',
+        treeOfThoughts: 'available',
+        selfReflection: 'available',
+        socraticReviewer: 'available'
+      },
+      crews: {
+        crews: 5,
+        totalAgents: 100,
+        crewNames: ['Alpha', 'Beta', 'Gamma', 'Delta', 'Epsilon']
+      },
+      d20: this.d20.getStatus()
+    };
+  }
+}