sigma-agents 0.1.7 → 0.1.8

package/package.json

@@ -1,15 +1,18 @@
 {
   "name": "sigma-agents",
-  "version": "0.1.7",
+  "version": "0.1.8",
   "description": "Intelligent sub-agent system with model routing for Phi Code",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "scripts": {
     "build": "tsc",
-    "clean": "rm -rf dist"
+    "clean": "shx rm -rf dist",
+    "prepublishOnly": "npm run clean && npm run build",
+    "test": "node --test dist/test/*.test.js"
   },
   "dependencies": {},
   "devDependencies": {
+    "shx": "^0.4.0",
     "typescript": "^5.4.0"
   },
   "repository": {
@@ -29,4 +32,4 @@
     "src",
     "README.md"
   ]
-}
+}

package/src/index.ts

@@ -1,4 +1,4 @@
-export { SmartRouter } from './router.js';
-export { ModelProfiler } from './profiles.js';
-export { SubAgentManager } from './sub-agent.js';
-export * from './types.js';
+export { ModelProfiler } from "./profiles.js";
+export { SmartRouter } from "./router.js";
+export { SubAgentManager } from "./sub-agent.js";
+export * from "./types.js";

package/src/profiles.ts

@@ -1,90 +1,128 @@
-import { ModelProfile, TaskCategory } from './types.js';
-import { readFile, writeFile } from 'node:fs/promises';
+import { readFile, writeFile } from "node:fs/promises";
+import type { ModelProfile, TaskCategory } from "./types.js";
 
 export class ModelProfiler {
-  public profiles: Map<string, ModelProfile> = new Map();
-
-  /**
-   * Charge les profiles depuis un fichier JSON
-   */
-  async loadFromFile(path: string): Promise<void> {
-    try {
-      const content = await readFile(path, 'utf8');
-      const data = JSON.parse(content);
-      
-      if (Array.isArray(data.profiles)) {
-        this.profiles.clear();
-        for (const profile of data.profiles) {
-          this.profiles.set(profile.id, profile);
-        }
-      }
-    } catch (error) {
-      // If file doesn't exist, use default profiles
-      console.warn(`Could not load profiles from ${path}:`, error);
-      this.loadDefaultProfiles();
-    }
-  }
-
-  /**
-   * Sauvegarde les profiles vers un fichier JSON
-   */
-  async saveToFile(path: string): Promise<void> {
-    const data = {
-      profiles: Array.from(this.profiles.values())
-    };
-    
-    await writeFile(path, JSON.stringify(data, null, 2), 'utf8');
-  }
-
-  /**
-   * Ajoute un profile
-   */
-  addProfile(profile: ModelProfile): void {
-    this.profiles.set(profile.id, profile);
-  }
-
-  /**
-   * Retourne le meilleur modèle pour une tâche donnée
-   */
-  getBestForTask(category: TaskCategory): ModelProfile | null {
-    const candidates = Array.from(this.profiles.values())
-      .filter(profile => profile.strengths.includes(category))
-      .sort((a, b) => {
-        // Priority: quality > speed
-        if (a.quality !== b.quality) {
-          const qualityOrder = { high: 3, medium: 2, low: 1 };
-          return qualityOrder[b.quality] - qualityOrder[a.quality];
-        }
-        
-        if (a.speed !== b.speed) {
-          const speedOrder = { fast: 3, medium: 2, slow: 1 };
-          return speedOrder[b.speed] - speedOrder[a.speed];
-        }
-        
-        return 0; // Equal priority
-      });
-    
-    return candidates[0] || null;
-  }
-
-  /**
-   * Charge les profiles par défaut des modèles Alibaba
-   */
-  private loadDefaultProfiles(): void {
-    const defaultProfiles = this.getDefaultProfiles();
-    this.profiles.clear();
-    
-    for (const profile of defaultProfiles) {
-      this.profiles.set(profile.id, profile);
-    }
-  }
-
-  /**
-   * Returns empty default profiles.
-   * Actual profiles should be populated from /phi-init or user configuration.
-   * sigma-agents is provider-agnostic — no hardcoded model names.
-   */
-  getDefaultProfiles(): ModelProfile[] {
-    return [];
-  }
-}
+	public profiles: Map<string, ModelProfile> = new Map();
+
+	/**
+	 * Charge les profiles depuis un fichier JSON
+	 */
+	async loadFromFile(path: string): Promise<void> {
+		try {
+			const content = await readFile(path, "utf8");
+			const data = JSON.parse(content);
+
+			if (Array.isArray(data.profiles)) {
+				this.profiles.clear();
+				for (const profile of data.profiles) {
+					if (!ModelProfiler.isValidProfile(profile)) {
+						console.warn("Skipping invalid profile entry");
+						continue;
+					}
+					this.profiles.set(profile.id, profile);
+				}
+			}
+		} catch (error) {
+			// If file doesn't exist, use default profiles
+			console.warn(`Could not load profiles from ${path}:`, error);
+			this.loadDefaultProfiles();
+		}
+	}
+
+	/**
+	 * Sauvegarde les profiles vers un fichier JSON
+	 */
+	async saveToFile(path: string): Promise<void> {
+		const data = {
+			profiles: Array.from(this.profiles.values()),
+		};
+
+		await writeFile(path, JSON.stringify(data, null, 2), "utf8");
+	}
+
+	/**
+	 * Ajoute un profile
+	 */
+	addProfile(profile: ModelProfile): void {
+		this.profiles.set(profile.id, profile);
+	}
+
+	/**
+	 * Retourne le meilleur modèle pour une tâche donnée
+	 */
+	getBestForTask(category: TaskCategory): ModelProfile | null {
+		const candidates = Array.from(this.profiles.values())
+			.filter((profile) => profile.strengths.includes(category))
+			.sort((a, b) => {
+				// Priority: quality > speed
+				if (a.quality !== b.quality) {
+					const qualityOrder = { high: 3, medium: 2, low: 1 };
+					return qualityOrder[b.quality] - qualityOrder[a.quality];
+				}
+
+				if (a.speed !== b.speed) {
+					const speedOrder = { fast: 3, medium: 2, slow: 1 };
+					return speedOrder[b.speed] - speedOrder[a.speed];
+				}
+
+				return 0; // Equal priority
+			});
+
+		return candidates[0] || null;
+	}
+
+	/**
+	 * Charge les profiles par défaut des modèles Alibaba
+	 */
+	private loadDefaultProfiles(): void {
+		const defaultProfiles = this.getDefaultProfiles();
+		this.profiles.clear();
+
+		for (const profile of defaultProfiles) {
+			this.profiles.set(profile.id, profile);
+		}
+	}
+
+	/**
+	 * Valide la forme d'un profile chargé depuis un JSON non fiable.
+	 * Empêche les entrées sans id (qui s'écraseraient sous la clé undefined)
+	 * et les champs malformés qui feraient planter getBestForTask.
+	 */
+	static isValidProfile(profile: unknown): profile is ModelProfile {
+		if (typeof profile !== "object" || profile === null) {
+			return false;
+		}
+
+		const p = profile as Record<string, unknown>;
+
+		if (typeof p.id !== "string" || p.id.length === 0) {
+			return false;
+		}
+		if (typeof p.provider !== "string") {
+			return false;
+		}
+		if (p.speed !== "fast" && p.speed !== "medium" && p.speed !== "slow") {
+			return false;
+		}
+		if (p.quality !== "high" && p.quality !== "medium" && p.quality !== "low") {
+			return false;
+		}
+		if (!Array.isArray(p.strengths) || !p.strengths.every((s) => typeof s === "string")) {
+			return false;
+		}
+		if (typeof p.maxTokens !== "number" || typeof p.supportsTools !== "boolean") {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Returns empty default profiles.
+	 * Actual profiles should be populated from /phi-init or user configuration.
+	 * sigma-agents is provider-agnostic — no hardcoded model names.
+	 */
+	getDefaultProfiles(): ModelProfile[] {
+		return [];
+	}
+}

package/src/router.ts

@@ -1,138 +1,277 @@
-import { RoutingConfig, TaskCategory } from './types.js';
-import { readFile } from 'node:fs/promises';
+import { readFile } from "node:fs/promises";
+import type { RoutingConfig, TaskCategory } from "./types.js";
 
 export class SmartRouter {
-  private config: RoutingConfig;
-
-  constructor(config: RoutingConfig) {
-    this.config = config;
-  }
-
-  /**
-   * Analyse le prompt et retourne la catégorie de tâche
-   * Priorité : debug > code > plan > review > test > explore > general
-   */
-  classifyTask(prompt: string): TaskCategory {
-    const lowerPrompt = prompt.toLowerCase();
-    const categories: TaskCategory[] = [];
-
-    // Check each category
-    for (const [category, route] of Object.entries(this.config.routes)) {
-      const hasKeyword = route.keywords.some(keyword => 
-        lowerPrompt.includes(keyword.toLowerCase())
-      );
-      
-      if (hasKeyword) {
-        categories.push(category as TaskCategory);
-      }
-    }
-
-    if (categories.length === 0) {
-      return 'general';
-    }
-
-    // Apply priorities
-    const priorityOrder: TaskCategory[] = ['debug', 'code', 'plan', 'review', 'test', 'explore', 'general'];
-    
-    for (const priority of priorityOrder) {
-      if (categories.includes(priority)) {
-        return priority;
-      }
-    }
-
-    return categories[0];
-  }
-
-  /**
-   * Retourne le modèle et l'agent recommandés pour un prompt
-   */
-  getRecommendation(prompt: string): { model: string; agent: string | null; category: TaskCategory } {
-    const category = this.classifyTask(prompt);
-    const route = this.config.routes[category];
-
-    if (!route) {
-      return {
-        model: this.config.default.model,
-        agent: this.config.default.agent,
-        category
-      };
-    }
-
-    return {
-      model: route.preferredModel,
-      agent: route.agent,
-      category
-    };
-  }
-
-  /**
-   * Charge la configuration depuis un fichier JSON
-   */
-  static async loadConfig(configPath: string): Promise<RoutingConfig> {
-    try {
-      const content = await readFile(configPath, 'utf8');
-      return JSON.parse(content);
-    } catch {
-      // File doesn't exist yet — use defaults silently
-      return SmartRouter.defaultConfig();
-    }
-  }
-
-  /**
-   * Default configuration with provider-agnostic model names.
-   * Uses 'default' as model placeholder — the actual model is determined
-   * at runtime by /phi-init or the user's routing.json.
-   */
-  static defaultConfig(): RoutingConfig {
-    return {
-      routes: {
-        code: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['code', 'implement', 'write', 'create', 'build', 'développer', 'coder', 'programmer', 'function', 'class', 'method']
-        },
-        debug: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['debug', 'fix', 'error', 'bug', 'broken', 'issue', 'problem', 'repair', 'correct', 'erreur', 'problème', 'réparer']
-        },
-        explore: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['explore', 'understand', 'analyze', 'examine', 'investigate', 'study', 'review', 'explorer', 'analyser', 'comprendre']
-        },
-        plan: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['plan', 'design', 'architecture', 'strategy', 'approach', 'structure', 'organize', 'concevoir', 'planifier', 'architecture']
-        },
-        test: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['test', 'testing', 'unit', 'integration', 'verify', 'validate', 'check', 'tester', 'vérifier', 'valider']
-        },
-        review: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['review', 'audit', 'check', 'validate', 'quality', 'improve', 'optimize', 'réviser', 'améliorer', 'optimiser']
-        },
-        general: {
-          preferredModel: 'default',
-          fallback: 'default',
-          agent: null,
-          keywords: ['help', 'explain', 'what', 'how', 'why', 'question', 'aide', 'expliquer', 'comment', 'pourquoi']
-        }
-      },
-      default: {
-        model: 'default',
-        agent: null
-      }
-    };
-  }
-}
+	private config: RoutingConfig;
+
+	constructor(config: RoutingConfig) {
+		this.config = config;
+	}
+
+	/**
+	 * Analyse le prompt et retourne la catégorie de tâche
+	 * Priorité : debug > code > plan > review > test > explore > general
+	 */
+	classifyTask(prompt: string): TaskCategory {
+		const lowerPrompt = prompt.toLowerCase();
+		const categories: TaskCategory[] = [];
+
+		if (!this.config?.routes) {
+			return "general";
+		}
+
+		// Check each category
+		for (const [category, route] of Object.entries(this.config.routes)) {
+			if (!Array.isArray(route?.keywords)) continue;
+			const hasKeyword = route.keywords.some((keyword) => lowerPrompt.includes(keyword.toLowerCase()));
+
+			if (hasKeyword) {
+				categories.push(category as TaskCategory);
+			}
+		}
+
+		if (categories.length === 0) {
+			return "general";
+		}
+
+		// Apply priorities
+		const priorityOrder: TaskCategory[] = ["debug", "code", "plan", "review", "test", "explore", "general"];
+
+		for (const priority of priorityOrder) {
+			if (categories.includes(priority)) {
+				return priority;
+			}
+		}
+
+		return categories[0];
+	}
+
+	/**
+	 * Retourne le modèle et l'agent recommandés pour un prompt
+	 */
+	getRecommendation(prompt: string): { model: string; agent: string | null; category: TaskCategory } {
+		const category = this.classifyTask(prompt);
+		const route = this.config.routes[category];
+
+		if (!route) {
+			return {
+				model: this.config.default.model,
+				agent: this.config.default.agent,
+				category,
+			};
+		}
+
+		return {
+			model: route.preferredModel,
+			agent: route.agent,
+			category,
+		};
+	}
+
+	/**
+	 * Charge la configuration depuis un fichier JSON
+	 */
+	static async loadConfig(configPath: string): Promise<RoutingConfig> {
+		try {
+			const content = await readFile(configPath, "utf8");
+			const parsed: unknown = JSON.parse(content);
+
+			if (!SmartRouter.validateRoutingConfig(parsed)) {
+				console.warn(
+					`Invalid routing config structure in ${configPath}; falling back to defaults`,
+				);
+				return SmartRouter.defaultConfig();
+			}
+
+			return parsed;
+		} catch {
+			// File doesn't exist yet — use defaults silently
+			return SmartRouter.defaultConfig();
+		}
+	}
+
+	/**
+	 * Valide la structure d'une RoutingConfig chargée depuis un fichier non fiable.
+	 * Fail-safe : retourne false sur toute incohérence structurelle.
+	 */
+	static validateRoutingConfig(config: unknown): config is RoutingConfig {
+		if (typeof config !== "object" || config === null) {
+			return false;
+		}
+
+		const candidate = config as Record<string, unknown>;
+
+		const routes = candidate.routes;
+		if (typeof routes !== "object" || routes === null) {
+			return false;
+		}
+
+		for (const route of Object.values(routes as Record<string, unknown>)) {
+			if (typeof route !== "object" || route === null) {
+				return false;
+			}
+			const r = route as Record<string, unknown>;
+			if (typeof r.preferredModel !== "string" || typeof r.fallback !== "string") {
+				return false;
+			}
+			if (!(r.agent === null || typeof r.agent === "string")) {
+				return false;
+			}
+			if (!Array.isArray(r.keywords) || !r.keywords.every((k) => typeof k === "string")) {
+				return false;
+			}
+		}
+
+		const defaults = candidate.default;
+		if (typeof defaults !== "object" || defaults === null) {
+			return false;
+		}
+		const d = defaults as Record<string, unknown>;
+		if (typeof d.model !== "string") {
+			return false;
+		}
+		if (!(d.agent === null || typeof d.agent === "string")) {
+			return false;
+		}
+
+		return true;
+	}
+
+	/**
+	 * Default configuration with provider-agnostic model names.
+	 * Uses 'default' as model placeholder — the actual model is determined
+	 * at runtime by /phi-init or the user's routing.json.
+	 */
+	static defaultConfig(): RoutingConfig {
+		return {
+			routes: {
+				code: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"code",
+						"implement",
+						"write",
+						"create",
+						"build",
+						"développer",
+						"coder",
+						"programmer",
+						"function",
+						"class",
+						"method",
+					],
+				},
+				debug: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"debug",
+						"fix",
+						"error",
+						"bug",
+						"broken",
+						"issue",
+						"problem",
+						"repair",
+						"correct",
+						"erreur",
+						"problème",
+						"réparer",
+					],
+				},
+				explore: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"explore",
+						"understand",
+						"analyze",
+						"examine",
+						"investigate",
+						"study",
+						"review",
+						"explorer",
+						"analyser",
+						"comprendre",
+					],
+				},
+				plan: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"plan",
+						"design",
+						"architecture",
+						"strategy",
+						"approach",
+						"structure",
+						"organize",
+						"concevoir",
+						"planifier",
+						"architecture",
+					],
+				},
+				test: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"test",
+						"testing",
+						"unit",
+						"integration",
+						"verify",
+						"validate",
+						"check",
+						"tester",
+						"vérifier",
+						"valider",
+					],
+				},
+				review: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"review",
+						"audit",
+						"check",
+						"validate",
+						"quality",
+						"improve",
+						"optimize",
+						"réviser",
+						"améliorer",
+						"optimiser",
+					],
+				},
+				general: {
+					preferredModel: "default",
+					fallback: "default",
+					agent: null,
+					keywords: [
+						"help",
+						"explain",
+						"what",
+						"how",
+						"why",
+						"question",
+						"aide",
+						"expliquer",
+						"comment",
+						"pourquoi",
+					],
+				},
+			},
+			default: {
+				model: "default",
+				agent: null,
+			},
+		};
+	}
+}