@yuaone/core 0.3.3 → 0.4.0

package/dist/specialist-registry.js

@@ -0,0 +1,413 @@
+/**
+ * @module specialist-registry
+ * @description Specialist Agent Registry — Domain-specific agent configurations.
+ *
+ * Each specialist has pre-loaded expertise, preferred tools, and quality thresholds.
+ * Routing: TaskClassifier -> SpecialistRegistry -> specialist config -> SubAgent
+ */
+// ─── SpecialistRegistry Class ───
+/**
+ * Registry for domain-specific specialist agent configurations.
+ *
+ * Manages built-in and custom specialists that can be matched to tasks
+ * based on type, language, framework, and error context.
+ *
+ * @example
+ * ```typescript
+ * const registry = new SpecialistRegistry();
+ *
+ * // Find best specialist for a TypeScript security task
+ * const match = registry.findSpecialist("security", {
+ *   language: "typescript",
+ * });
+ * if (match) {
+ *   console.log(match.specialist.name); // "Security Specialist"
+ *   console.log(match.confidence);      // 0.9
+ * }
+ *
+ * // Register a custom specialist
+ * registry.register({
+ *   id: "rust-specialist",
+ *   name: "Rust Specialist",
+ *   domain: "Rust systems programming",
+ *   systemPrompt: "You are a Rust expert...",
+ *   preferredTools: ["file_read", "file_edit", "shell_exec"],
+ *   preferredSkills: ["cargo-check", "clippy-lint"],
+ *   qualityThreshold: 0.85,
+ *   languages: ["rust"],
+ * });
+ * ```
+ */
+export class SpecialistRegistry {
+    specialists = new Map();
+    constructor() {
+        this.registerBuiltins();
+    }
+    /**
+     * Register a specialist configuration.
+     * If a specialist with the same ID exists, it is replaced.
+     *
+     * @param config - Specialist configuration to register
+     */
+    register(config) {
+        this.specialists.set(config.id, config);
+    }
+    /**
+     * Find the best specialist for a given task type and context.
+     *
+     * Matching priority:
+     * 1. Exact task type match
+     * 2. Language/framework affinity bonus
+     * 3. Error message pattern match
+     *
+     * @param taskType - Task type string (from TaskClassifier)
+     * @param context - Optional context for better matching
+     * @returns Best matching specialist or null if none found
+     */
+    findSpecialist(taskType, context) {
+        const candidates = [];
+        for (const specialist of this.specialists.values()) {
+            let confidence = 0;
+            let reason = "";
+            // 1. Domain match via specialist ID or domain keywords
+            if (this.matchesDomain(specialist, taskType)) {
+                confidence = 0.7;
+                reason = `Domain match: ${specialist.domain}`;
+            }
+            // 2. Language affinity bonus
+            if (context?.language &&
+                specialist.languages?.some((lang) => lang.toLowerCase() === context.language.toLowerCase())) {
+                confidence += 0.15;
+                reason += reason ? "; language match" : `Language match: ${context.language}`;
+            }
+            // 3. Framework affinity bonus
+            if (context?.framework &&
+                specialist.frameworks?.some((fw) => fw.toLowerCase() === context.framework.toLowerCase())) {
+                confidence += 0.1;
+                reason += reason ? "; framework match" : `Framework match: ${context.framework}`;
+            }
+            // 4. Error message pattern match (for debugger/security specialists)
+            if (context?.errorMessage && specialist.id === "security-specialist") {
+                const securityPatterns = /xss|csrf|injection|auth|token|secret|vuln/i;
+                if (securityPatterns.test(context.errorMessage)) {
+                    confidence += 0.15;
+                    reason += "; security error pattern detected";
+                }
+            }
+            if (confidence > 0) {
+                candidates.push({
+                    specialist,
+                    confidence: Math.min(1.0, confidence),
+                    reason,
+                });
+            }
+        }
+        if (candidates.length === 0)
+            return null;
+        // Return highest confidence match (lexicographic tie-break for determinism)
+        candidates.sort((a, b) => {
+            if (b.confidence !== a.confidence)
+                return b.confidence - a.confidence;
+            return a.specialist.id.localeCompare(b.specialist.id);
+        });
+        return candidates[0];
+    }
+    /**
+     * Get a specialist by its unique ID.
+     *
+     * @param id - Specialist ID
+     * @returns Specialist config or undefined if not found
+     */
+    get(id) {
+        return this.specialists.get(id);
+    }
+    /**
+     * List all registered specialists.
+     *
+     * @returns Array of all specialist configurations
+     */
+    list() {
+        return Array.from(this.specialists.values());
+    }
+    /**
+     * Remove a specialist by ID.
+     *
+     * @param id - Specialist ID to remove
+     * @returns true if removed, false if not found
+     */
+    remove(id) {
+        return this.specialists.delete(id);
+    }
+    /**
+     * Get the total number of registered specialists.
+     */
+    get size() {
+        return this.specialists.size;
+    }
+    // ─── Private Helpers ───
+    /**
+     * Check if a specialist's domain matches the given task type.
+     */
+    matchesDomain(specialist, taskType) {
+        const normalizedType = taskType.toLowerCase();
+        // Direct ID match patterns
+        const domainMap = {
+            "typescript-specialist": ["feature", "refactor", "config"],
+            "react-specialist": ["feature", "design", "refactor"],
+            "infra-specialist": ["infra", "deploy"],
+            "testing-specialist": ["test"],
+            "security-specialist": ["security"],
+            "python-specialist": ["feature", "refactor"],
+            "database-specialist": ["migration", "feature", "performance"],
+            "performance-specialist": ["performance"],
+        };
+        const matchTypes = domainMap[specialist.id];
+        if (matchTypes && matchTypes.includes(normalizedType)) {
+            return true;
+        }
+        // Fallback: check domain description keywords
+        return specialist.domain.toLowerCase().includes(normalizedType);
+    }
+    /**
+     * Register all built-in specialist configurations.
+     */
+    registerBuiltins() {
+        // 1. TypeScript Specialist
+        this.register({
+            id: "typescript-specialist",
+            name: "TypeScript Specialist",
+            domain: "TypeScript type system, generics, and advanced patterns",
+            systemPrompt: `You are a TypeScript expert. Your strength is leveraging the type system for maximum safety and developer experience.
+
+Expertise:
+- Strict mode, noUncheckedIndexedAccess, exactOptionalPropertyTypes
+- Generic constraints, conditional types, mapped types, template literals
+- Type inference optimization — let TS infer when possible, annotate when ambiguous
+- Declaration files (.d.ts) for untyped dependencies
+- tsconfig optimization for monorepos (composite, references, paths)
+- Discriminated unions over type assertions; exhaustive switches with never
+
+Rules:
+- Never use \`any\` — use \`unknown\` with type guards instead
+- Prefer \`interface\` for objects, \`type\` for unions/intersections/utility types
+- Use \`satisfies\` for type-safe object literals with inference
+- Export types explicitly; avoid re-exporting \`*\` from barrel files
+- Use \`as const\` for literal type inference on constant arrays/objects`,
+            preferredTools: ["file_read", "file_edit", "grep", "shell_exec"],
+            preferredSkills: ["type-check", "tsconfig-lint"],
+            qualityThreshold: 0.85,
+            languages: ["typescript", "javascript"],
+            frameworks: ["node", "deno", "bun"],
+            canDelegateTo: ["react-specialist", "testing-specialist"],
+        });
+        // 2. React Specialist
+        this.register({
+            id: "react-specialist",
+            name: "React Specialist",
+            domain: "React, hooks, SSR/hydration, state management, and Next.js",
+            systemPrompt: `You are a React expert. Your goal: build performant, accessible UI with clean component architecture.
+
+Expertise:
+- Hooks: useState, useEffect, useCallback, useMemo, useRef, custom hooks
+- SSR/hydration pitfalls: useEffect vs useLayoutEffect, window checks, dynamic imports
+- State management: Zustand, React Query/TanStack Query, context (sparingly)
+- Performance: React.memo, useMemo, useCallback — only when measured as needed
+- Next.js: App Router, Server Components, route handlers, middleware, ISR/SSG
+- Suspense boundaries, error boundaries, streaming SSR
+
+Rules:
+- Prefer Server Components by default; use 'use client' only when needed
+- Never store derived state — compute it during render
+- Keep components small (<100 lines); extract hooks for reusable logic
+- Use \`key\` prop correctly to avoid stale state bugs
+- Always handle loading, error, and empty states
+- Accessibility: semantic HTML, ARIA labels, keyboard navigation`,
+            preferredTools: ["file_read", "file_edit", "file_write", "glob", "shell_exec"],
+            preferredSkills: ["component-lint", "accessibility-check", "bundle-analyzer"],
+            qualityThreshold: 0.80,
+            languages: ["typescript", "javascript"],
+            frameworks: ["react", "next.js", "remix", "gatsby"],
+            canDelegateTo: ["typescript-specialist", "performance-specialist"],
+        });
+        // 3. Infrastructure Specialist
+        this.register({
+            id: "infra-specialist",
+            name: "Infrastructure Specialist",
+            domain: "DevOps, Docker, CI/CD, Terraform, Kubernetes, cloud services",
+            systemPrompt: `You are an infrastructure and DevOps expert. Your goal: reliable, reproducible, secure deployments.
+
+Expertise:
+- Docker: multi-stage builds, layer caching, minimal images (distroless/alpine)
+- CI/CD: GitHub Actions, GitLab CI, Jenkins — caching, matrix builds, artifact management
+- Terraform/IaC: state management, modules, workspaces, drift detection
+- Kubernetes: deployments, services, ingress, HPA, resource limits, health checks
+- Cloud: AWS (ECS, Lambda, RDS, S3), GCP (Cloud Run, GKE), Azure basics
+- Monitoring: Prometheus, Grafana, CloudWatch, structured logging, alerting rules
+
+Rules:
+- Always pin versions (Docker tags, Terraform providers, CI action versions)
+- Secrets via env vars or secret managers — never hardcode
+- Health checks on every service; graceful shutdown handlers
+- Least-privilege IAM roles and network policies
+- Idempotent deployments; rollback strategy for every change
+- Cost awareness: right-size resources, use spot/preemptible when safe`,
+            preferredTools: ["file_read", "file_edit", "shell_exec", "file_write"],
+            preferredSkills: ["docker-lint", "terraform-validate", "cloud-cost-estimate"],
+            qualityThreshold: 0.85,
+            languages: ["yaml", "hcl", "bash", "typescript"],
+            frameworks: ["docker", "kubernetes", "terraform", "github-actions"],
+            canDelegateTo: ["security-specialist"],
+        });
+        // 4. Testing Specialist
+        this.register({
+            id: "testing-specialist",
+            name: "Testing Specialist",
+            domain: "Unit, integration, e2e testing, TDD, mocking, coverage",
+            systemPrompt: `You are a testing expert. Your goal: comprehensive, maintainable tests that catch real bugs.
+
+Expertise:
+- Unit tests: isolated, fast, one assertion per concept, AAA pattern (Arrange/Act/Assert)
+- Integration tests: test module boundaries, real dependencies where practical
+- E2E tests: critical user flows, stable selectors, retry logic, visual regression
+- Mocking: minimal mocks — prefer fakes/stubs; mock at boundaries, not internals
+- Coverage: line coverage is necessary but not sufficient; branch and path coverage matter
+- TDD: red-green-refactor cycle when building new features
+
+Rules:
+- Test behavior, not implementation details
+- Name tests: "should [expected behavior] when [condition]"
+- No test interdependence — each test sets up its own state
+- Prefer \`describe/it\` grouping for readability
+- Mock external APIs, databases, file system — not your own code
+- Flaky tests are bugs: fix or quarantine immediately
+- Aim for fast feedback: unit > integration > e2e (testing pyramid)`,
+            preferredTools: ["file_read", "file_write", "file_edit", "shell_exec", "grep"],
+            preferredSkills: ["test-generator", "coverage-analysis", "mock-generator"],
+            qualityThreshold: 0.80,
+            languages: ["typescript", "javascript", "python"],
+            frameworks: ["vitest", "jest", "playwright", "pytest", "mocha"],
+            canDelegateTo: ["typescript-specialist"],
+        });
+        // 5. Security Specialist
+        this.register({
+            id: "security-specialist",
+            name: "Security Specialist",
+            domain: "OWASP top 10, auth, injection prevention, secrets management, dependency auditing",
+            systemPrompt: `You are a security expert. Your goal: identify and remediate vulnerabilities before they reach production.
+
+Expertise:
+- OWASP Top 10: injection (SQL, NoSQL, OS cmd), XSS (reflected/stored/DOM), CSRF, SSRF
+- Authentication: bcrypt/argon2 hashing, JWT best practices, session management, MFA
+- Authorization: RBAC, ABAC, least privilege, broken access control patterns
+- Secrets: never in code/logs; use vault/env vars; rotate regularly; detect with scanners
+- Dependencies: npm audit, Snyk, Dependabot; pin versions; monitor CVEs
+- Headers: CSP, HSTS, X-Frame-Options, X-Content-Type-Options, Referrer-Policy
+- Input validation: allowlist over denylist; parameterized queries; output encoding
+
+Rules:
+- Defense in depth: never rely on a single control
+- Fail secure: errors should deny access, not grant it
+- Log security events but never log sensitive data (passwords, tokens, PII)
+- Rate limiting on auth endpoints; account lockout with notification
+- HTTPS everywhere; secure cookie flags (HttpOnly, Secure, SameSite)
+- Regular dependency audits; automated vulnerability scanning in CI`,
+            preferredTools: ["grep", "file_read", "shell_exec", "file_edit"],
+            preferredSkills: ["vulnerability-scan", "secret-detection", "dependency-audit"],
+            qualityThreshold: 0.90,
+            languages: ["typescript", "javascript", "python", "go"],
+            frameworks: ["express", "next.js", "fastapi", "django"],
+            canDelegateTo: ["infra-specialist"],
+        });
+        // 6. Python Specialist
+        this.register({
+            id: "python-specialist",
+            name: "Python Specialist",
+            domain: "Python async, type hints, FastAPI/Django, data processing, packaging",
+            systemPrompt: `You are a Python expert. Your goal: idiomatic, well-typed, performant Python code.
+
+Expertise:
+- Async: asyncio, aiohttp, async generators; understand event loop mechanics
+- Type hints: typing module, Protocol, TypeVar, ParamSpec, overload, TypeGuard
+- Frameworks: FastAPI (Pydantic models, dependency injection), Django (ORM, middleware)
+- Data: pandas, polars, numpy patterns; efficient chunked processing for large datasets
+- Packaging: pyproject.toml, poetry/uv, virtual environments, wheel building
+- Testing: pytest fixtures, parametrize, monkeypatch, hypothesis for property-based tests
+
+Rules:
+- Use type hints on all public functions and class methods
+- Prefer dataclasses/Pydantic models over plain dicts for structured data
+- Use pathlib.Path over os.path; f-strings over format/concatenation
+- Context managers for resource cleanup (files, connections, locks)
+- List comprehensions for simple transforms; generators for large data
+- Follow PEP 8; use ruff for linting and formatting`,
+            preferredTools: ["file_read", "file_edit", "shell_exec", "file_write", "grep"],
+            preferredSkills: ["type-check", "ruff-lint", "pytest-runner"],
+            qualityThreshold: 0.80,
+            languages: ["python"],
+            frameworks: ["fastapi", "django", "flask", "pytorch", "pandas"],
+            canDelegateTo: ["testing-specialist", "database-specialist"],
+        });
+        // 7. Database Specialist
+        this.register({
+            id: "database-specialist",
+            name: "Database Specialist",
+            domain: "SQL optimization, indexing, migration, ORM patterns, connection pooling",
+            systemPrompt: `You are a database expert. Your goal: correct, performant, and safe data operations.
+
+Expertise:
+- SQL: query optimization, EXPLAIN ANALYZE, index design (B-tree, GIN, GiST, partial)
+- Migrations: zero-downtime schema changes, backward-compatible migrations, rollback plans
+- ORMs: Prisma, Drizzle, TypeORM, SQLAlchemy — when to use raw SQL vs ORM
+- Connection pooling: PgBouncer, connection limits, idle timeout, pool sizing
+- Patterns: soft delete, audit trails, optimistic locking, event sourcing basics
+- NoSQL: when to use (document, KV, graph); MongoDB, Redis, DynamoDB patterns
+
+Rules:
+- Always add indexes for columns used in WHERE, JOIN, ORDER BY
+- Never SELECT *; specify columns explicitly
+- Use transactions for multi-statement writes; understand isolation levels
+- Parameterized queries always — never string interpolation for SQL
+- Migration scripts must be idempotent and reversible
+- Test migrations on a copy of production data before deploying
+- Monitor slow queries; set up query logging and alerting`,
+            preferredTools: ["file_read", "file_edit", "shell_exec", "grep"],
+            preferredSkills: ["query-analyzer", "migration-validator", "schema-lint"],
+            qualityThreshold: 0.85,
+            languages: ["sql", "typescript", "python"],
+            frameworks: ["prisma", "drizzle", "typeorm", "sqlalchemy", "knex"],
+            canDelegateTo: ["infra-specialist", "performance-specialist"],
+        });
+        // 8. Performance Specialist
+        this.register({
+            id: "performance-specialist",
+            name: "Performance Specialist",
+            domain: "Profiling, bundle optimization, lazy loading, caching, algorithmic complexity",
+            systemPrompt: `You are a performance expert. Your goal: measurable, impactful optimizations based on data, not guesswork.
+
+Expertise:
+- Profiling: Chrome DevTools, Node.js --inspect, flame graphs, heap snapshots
+- Bundle: tree shaking, code splitting, dynamic imports, bundle analysis (webpack-bundle-analyzer)
+- Rendering: virtual scrolling, windowing (react-window/virtuoso), layout thrashing prevention
+- Caching: HTTP cache headers, service workers, in-memory caches (LRU), CDN edge caching
+- Algorithms: Big-O analysis, data structure selection, avoiding N+1 queries
+- Network: request waterfall optimization, prefetch/preload, compression (gzip/brotli)
+- Core Web Vitals: LCP, FID/INP, CLS — measurement and improvement strategies
+
+Rules:
+- Measure before optimizing — use benchmarks and profiler data
+- Optimize the bottleneck, not the whole system
+- Prefer algorithmic improvements (O(n) vs O(n^2)) over micro-optimizations
+- Lazy load non-critical resources; prioritize above-the-fold content
+- Cache invalidation strategy is as important as caching itself
+- Document performance budgets and set up CI checks for regressions
+- Test on real devices and slow networks, not just developer machines`,
+            preferredTools: ["grep", "file_read", "shell_exec", "file_edit"],
+            preferredSkills: ["profiler", "bundle-analyzer", "cache-advisor", "lighthouse-audit"],
+            qualityThreshold: 0.80,
+            languages: ["typescript", "javascript", "python", "go"],
+            frameworks: ["react", "next.js", "node", "webpack", "vite"],
+            canDelegateTo: ["react-specialist", "database-specialist"],
+        });
+    }
+}
+//# sourceMappingURL=specialist-registry.js.map

package/dist/specialist-registry.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"specialist-registry.js","sourceRoot":"","sources":["../src/specialist-registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAsCH,mCAAmC;AAEnC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,MAAM,OAAO,kBAAkB;IACrB,WAAW,GAAkC,IAAI,GAAG,EAAE,CAAC;IAE/D;QACE,IAAI,CAAC,gBAAgB,EAAE,CAAC;IAC1B,CAAC;IAED;;;;;OAKG;IACH,QAAQ,CAAC,MAAwB;QAC/B,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,EAAE,MAAM,CAAC,CAAC;IAC1C,CAAC;IAED;;;;;;;;;;;OAWG;IACH,cAAc,CACZ,QAAgB,EAChB,OAIC;QAED,MAAM,UAAU,GAAsB,EAAE,CAAC;QAEzC,KAAK,MAAM,UAAU,IAAI,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,EAAE,CAAC;YACnD,IAAI,UAAU,GAAG,CAAC,CAAC;YACnB,IAAI,MAAM,GAAG,EAAE,CAAC;YAEhB,uDAAuD;YACvD,IAAI,IAAI,CAAC,aAAa,CAAC,UAAU,EAAE,QAAQ,CAAC,EAAE,CAAC;gBAC7C,UAAU,GAAG,GAAG,CAAC;gBACjB,MAAM,GAAG,iBAAiB,UAAU,CAAC,MAAM,EAAE,CAAC;YAChD,CAAC;YAED,6BAA6B;YAC7B,IACE,OAAO,EAAE,QAAQ;gBACjB,UAAU,CAAC,SAAS,EAAE,IAAI,CACxB,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,QAAS,CAAC,WAAW,EAAE,CACjE,EACD,CAAC;gBACD,UAAU,IAAI,IAAI,CAAC;gBACnB,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,mBAAmB,OAAO,CAAC,QAAQ,EAAE,CAAC;YAChF,CAAC;YAED,8BAA8B;YAC9B,IACE,OAAO,EAAE,SAAS;gBAClB,UAAU,CAAC,UAAU,EAAE,IAAI,CACzB,CAAC,EAAE,EAAE,EAAE,CAAC,EAAE,CAAC,WAAW,EAAE,KAAK,OAAO,CAAC,SAAU,CAAC,WAAW,EAAE,CAC9D,EACD,CAAC;gBACD,UAAU,IAAI,GAAG,CAAC;gBAClB,MAAM,IAAI,MAAM,CAAC,CAAC,CAAC,mBAAmB,CAAC,CAAC,CAAC,oBAAoB,OAAO,CAAC,SAAS,EAAE,CAAC;YACnF,CAAC;YAED,qEAAqE;YACrE,IAAI,OAAO,EAAE,YAAY,IAAI,UAAU,CAAC,EAAE,KAAK,qBAAqB,EAAE,CAAC;gBACrE,MAAM,gBAAgB,GAAG,4CAA4C,CAAC;gBACtE,IAAI,gBAAgB,CAAC,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;oBAChD,UAAU,IAAI,IAAI,CAAC;oBACnB,MAAM,IAAI,mCAAmC,CAAC;gBAChD,CAAC;YACH,CAAC;YAED,IAAI,UAAU,GAAG,CAAC,EAAE,CAAC;gBACnB,UAAU,CAAC,IAAI,CAAC;oBACd,UAAU;oBACV,UAAU,EAAE,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,UAAU,CAAC;oBACrC,MAAM;iBACP,CAAC,CAAC;YACL,CAAC;QACH,CAAC;QAED,IAAI,UAAU,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QAEzC,4EAA4E;QAC5E,UAAU,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;YACvB,IAAI,CAAC,CAAC,UAAU,KAAK,CAAC,CAAC,UAAU;gBAAE,OAAO,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,UAAU,CAAC;YACtE,OAAO,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QACxD,CAAC,CAAC,CAAC;QACH,OAAO,UAAU,CAAC,CAAC,CAAC,CAAC;IACvB,CAAC;IAED;;;;;OAKG;IACH,GAAG,CAAC,EAAU;QACZ,OAAO,IAAI,CAAC,WAAW,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;IAClC,CAAC;IAED;;;;OAIG;IACH,IAAI;QACF,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;OAKG;IACH,MAAM,CAAC,EAAU;QACf,OAAO,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;IACrC,CAAC;IAED;;OAEG;IACH,IAAI,IAAI;QACN,OAAO,IAAI,CAAC,WAAW,CAAC,IAAI,CAAC;IAC/B,CAAC;IAED,0BAA0B;IAE1B;;OAEG;IACK,aAAa,CAAC,UAA4B,EAAE,QAAgB;QAClE,MAAM,cAAc,GAAG,QAAQ,CAAC,WAAW,EAAE,CAAC;QAE9C,2BAA2B;QAC3B,MAAM,SAAS,GAA6B;YAC1C,uBAAuB,EAAE,CAAC,SAAS,EAAE,UAAU,EAAE,QAAQ,CAAC;YAC1D,kBAAkB,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,UAAU,CAAC;YACrD,kBAAkB,EAAE,CAAC,OAAO,EAAE,QAAQ,CAAC;YACvC,oBAAoB,EAAE,CAAC,MAAM,CAAC;YAC9B,qBAAqB,EAAE,CAAC,UAAU,CAAC;YACnC,mBAAmB,EAAE,CAAC,SAAS,EAAE,UAAU,CAAC;YAC5C,qBAAqB,EAAE,CAAC,WAAW,EAAE,SAAS,EAAE,aAAa,CAAC;YAC9D,wBAAwB,EAAE,CAAC,aAAa,CAAC;SAC1C,CAAC;QAEF,MAAM,UAAU,GAAG,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC;QAC5C,IAAI,UAAU,IAAI,UAAU,CAAC,QAAQ,CAAC,cAAc,CAAC,EAAE,CAAC;YACtD,OAAO,IAAI,CAAC;QACd,CAAC;QAED,8CAA8C;QAC9C,OAAO,UAAU,CAAC,MAAM,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,cAAc,CAAC,CAAC;IAClE,CAAC;IAED;;OAEG;IACK,gBAAgB;QACtB,2BAA2B;QAC3B,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,uBAAuB;YAC3B,IAAI,EAAE,uBAAuB;YAC7B,MAAM,EAAE,yDAAyD;YACjE,YAAY,EAAE;;;;;;;;;;;;;;;yEAeqD;YACnE,cAAc,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,YAAY,CAAC;YAChE,eAAe,EAAE,CAAC,YAAY,EAAE,eAAe,CAAC;YAChD,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC;YACvC,UAAU,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,CAAC;YACnC,aAAa,EAAE,CAAC,kBAAkB,EAAE,oBAAoB,CAAC;SAC1D,CAAC,CAAC;QAEH,sBAAsB;QACtB,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,kBAAkB;YACtB,IAAI,EAAE,kBAAkB;YACxB,MAAM,EAAE,4DAA4D;YACpE,YAAY,EAAE;;;;;;;;;;;;;;;;iEAgB6C;YAC3D,cAAc,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,EAAE,YAAY,CAAC;YAC9E,eAAe,EAAE,CAAC,gBAAgB,EAAE,qBAAqB,EAAE,iBAAiB,CAAC;YAC7E,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,CAAC;YACvC,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,OAAO,EAAE,QAAQ,CAAC;YACnD,aAAa,EAAE,CAAC,uBAAuB,EAAE,wBAAwB,CAAC;SACnE,CAAC,CAAC;QAEH,+BAA+B;QAC/B,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,kBAAkB;YACtB,IAAI,EAAE,2BAA2B;YACjC,MAAM,EAAE,8DAA8D;YACtE,YAAY,EAAE;;;;;;;;;;;;;;;;uEAgBmD;YACjE,cAAc,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,CAAC;YACtE,eAAe,EAAE,CAAC,aAAa,EAAE,oBAAoB,EAAE,qBAAqB,CAAC;YAC7E,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,YAAY,CAAC;YAChD,UAAU,EAAE,CAAC,QAAQ,EAAE,YAAY,EAAE,WAAW,EAAE,gBAAgB,CAAC;YACnE,aAAa,EAAE,CAAC,qBAAqB,CAAC;SACvC,CAAC,CAAC;QAEH,wBAAwB;QACxB,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,oBAAoB;YACxB,IAAI,EAAE,oBAAoB;YAC1B,MAAM,EAAE,wDAAwD;YAChE,YAAY,EAAE;;;;;;;;;;;;;;;;;oEAiBgD;YAC9D,cAAc,EAAE,CAAC,WAAW,EAAE,YAAY,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,CAAC;YAC9E,eAAe,EAAE,CAAC,gBAAgB,EAAE,mBAAmB,EAAE,gBAAgB,CAAC;YAC1E,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,CAAC;YACjD,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,YAAY,EAAE,QAAQ,EAAE,OAAO,CAAC;YAC/D,aAAa,EAAE,CAAC,uBAAuB,CAAC;SACzC,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,qBAAqB;YACzB,IAAI,EAAE,qBAAqB;YAC3B,MAAM,EAAE,mFAAmF;YAC3F,YAAY,EAAE;;;;;;;;;;;;;;;;;oEAiBgD;YAC9D,cAAc,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,CAAC;YAChE,eAAe,EAAE,CAAC,oBAAoB,EAAE,kBAAkB,EAAE,kBAAkB,CAAC;YAC/E,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC;YACvD,UAAU,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,CAAC;YACvD,aAAa,EAAE,CAAC,kBAAkB,CAAC;SACpC,CAAC,CAAC;QAEH,uBAAuB;QACvB,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,mBAAmB;YACvB,IAAI,EAAE,mBAAmB;YACzB,MAAM,EAAE,sEAAsE;YAC9E,YAAY,EAAE;;;;;;;;;;;;;;;;oDAgBgC;YAC9C,cAAc,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,CAAC;YAC9E,eAAe,EAAE,CAAC,YAAY,EAAE,WAAW,EAAE,eAAe,CAAC;YAC7D,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,QAAQ,CAAC;YACrB,UAAU,EAAE,CAAC,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,CAAC;YAC/D,aAAa,EAAE,CAAC,oBAAoB,EAAE,qBAAqB,CAAC;SAC7D,CAAC,CAAC;QAEH,yBAAyB;QACzB,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,qBAAqB;YACzB,IAAI,EAAE,qBAAqB;YAC3B,MAAM,EAAE,yEAAyE;YACjF,YAAY,EAAE;;;;;;;;;;;;;;;;;0DAiBsC;YACpD,cAAc,EAAE,CAAC,WAAW,EAAE,WAAW,EAAE,YAAY,EAAE,MAAM,CAAC;YAChE,eAAe,EAAE,CAAC,gBAAgB,EAAE,qBAAqB,EAAE,aAAa,CAAC;YACzE,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,KAAK,EAAE,YAAY,EAAE,QAAQ,CAAC;YAC1C,UAAU,EAAE,CAAC,QAAQ,EAAE,SAAS,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC;YAClE,aAAa,EAAE,CAAC,kBAAkB,EAAE,wBAAwB,CAAC;SAC9D,CAAC,CAAC;QAEH,4BAA4B;QAC5B,IAAI,CAAC,QAAQ,CAAC;YACZ,EAAE,EAAE,wBAAwB;YAC5B,IAAI,EAAE,wBAAwB;YAC9B,MAAM,EAAE,+EAA+E;YACvF,YAAY,EAAE;;;;;;;;;;;;;;;;;;sEAkBkD;YAChE,cAAc,EAAE,CAAC,MAAM,EAAE,WAAW,EAAE,YAAY,EAAE,WAAW,CAAC;YAChE,eAAe,EAAE,CAAC,UAAU,EAAE,iBAAiB,EAAE,eAAe,EAAE,kBAAkB,CAAC;YACrF,gBAAgB,EAAE,IAAI;YACtB,SAAS,EAAE,CAAC,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,IAAI,CAAC;YACvD,UAAU,EAAE,CAAC,OAAO,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,CAAC;YAC3D,aAAa,EAAE,CAAC,kBAAkB,EAAE,qBAAqB,CAAC;SAC3D,CAAC,CAAC;IACL,CAAC;CACF"}

package/dist/sub-agent-prompts.d.ts

@@ -0,0 +1,45 @@
+/**
+ * @module sub-agent-prompts
+ * @description Role-specific, token-optimized prompts for sub-agents.
+ *
+ * Design principles:
+ * 1. Shorter prompts → fewer input tokens → lower cost
+ * 2. Clearer constraints → better first-attempt quality → fewer iterations
+ * 3. Output format → structured responses → easier parsing
+ * 4. Domain expertise → fewer mistakes → less back-and-forth
+ */
+export type SubAgentRole = "coder" | "reviewer" | "tester" | "debugger" | "refactorer" | "planner";
+export interface SubAgentPromptConfig {
+    /** Sub-agent role determines the system prompt template */
+    role: SubAgentRole;
+    /** Primary language (e.g. "typescript", "python") */
+    language?: string;
+    /** Framework in use (e.g. "react", "next.js") */
+    framework?: string;
+    /** Brief project description for context */
+    projectContext?: string;
+    /** Additional constraints injected verbatim */
+    constraints?: string[];
+}
+/**
+ * Build an optimized system prompt for a sub-agent.
+ *
+ * Assembles role-specific instructions, optional language standards,
+ * framework context, and custom constraints into a single prompt.
+ *
+ * Target: <800 tokens for simple roles, <1200 for complex roles.
+ *
+ * @param config - Prompt configuration specifying role and context
+ * @returns Fully constructed system prompt string
+ */
+export declare function buildSubAgentPrompt(config: SubAgentPromptConfig): string;
+/**
+ * Get the role-specific prompt template without additional context.
+ * Useful for inspecting or testing individual role prompts.
+ */
+export declare function getRolePrompt(role: SubAgentRole): string;
+/**
+ * Get all available sub-agent roles.
+ */
+export declare function getAvailableRoles(): SubAgentRole[];
+//# sourceMappingURL=sub-agent-prompts.d.ts.map

package/dist/sub-agent-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub-agent-prompts.d.ts","sourceRoot":"","sources":["../src/sub-agent-prompts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAMH,MAAM,MAAM,YAAY,GACpB,OAAO,GACP,UAAU,GACV,QAAQ,GACR,UAAU,GACV,YAAY,GACZ,SAAS,CAAC;AAEd,MAAM,WAAW,oBAAoB;IACnC,2DAA2D;IAC3D,IAAI,EAAE,YAAY,CAAC;IACnB,qDAAqD;IACrD,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,iDAAiD;IACjD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,4CAA4C;IAC5C,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,MAAM,EAAE,CAAC;CACxB;AAoGD;;;;;;;;;;GAUG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,oBAAoB,GAAG,MAAM,CAyCxE;AAED;;;GAGG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,CAExD;AAED;;GAEG;AACH,wBAAgB,iBAAiB,IAAI,YAAY,EAAE,CAElD"}

package/dist/sub-agent-prompts.js

@@ -0,0 +1,177 @@
+/**
+ * @module sub-agent-prompts
+ * @description Role-specific, token-optimized prompts for sub-agents.
+ *
+ * Design principles:
+ * 1. Shorter prompts → fewer input tokens → lower cost
+ * 2. Clearer constraints → better first-attempt quality → fewer iterations
+ * 3. Output format → structured responses → easier parsing
+ * 4. Domain expertise → fewer mistakes → less back-and-forth
+ */
+import { getCodingStandards } from "./coding-standards.js";
+// ─── Role Prompt Templates ───
+// Each template is kept concise: ~400-600 tokens to minimize input cost.
+const ROLE_PROMPTS = {
+    coder: `You are a precise coding agent. Your goal: write minimal, correct code on the first attempt.
+
+Rules:
+- Read existing code before writing. Match the project's style, patterns, and conventions exactly.
+- Make the smallest change that achieves the goal. No unnecessary abstractions, comments, or over-engineering.
+- Prefer editing existing files (file_edit) over full rewrites (file_write).
+- After changes, verify with build/lint/typecheck. Fix any errors before reporting done.
+- Never modify files outside your assigned scope.
+
+Output format:
+1. Brief plan (1-3 lines)
+2. Code changes (use tools)
+3. Verification result (build/lint output)
+4. Summary: files changed + what was done`,
+    reviewer: `You are a code review agent. Focus on correctness, security, and performance — in that order.
+
+Rules:
+- Read all changed files thoroughly before judging.
+- Flag only real issues: bugs, security holes, perf problems, broken contracts.
+- No style nits unless they cause bugs. No suggestions for "nice to have" improvements.
+- Be specific: cite file, line, and the exact problem.
+
+Output format (JSON):
+{
+  "verdict": "approve" | "request_changes" | "comment",
+  "issues": [{ "severity": "critical|high|medium", "file": "...", "line": N, "description": "..." }],
+  "confidence": 0.0-1.0,
+  "summary": "one line"
+}`,
+    tester: `You are a test-writing agent. Write tests that catch real bugs, not ceremonial coverage.
+
+Rules:
+- Test behavior and contracts, not implementation details.
+- Cover: happy path, edge cases, error paths, boundary values.
+- Keep tests independent — no shared mutable state between tests.
+- Use the project's existing test framework and patterns.
+- Run tests after writing. Fix failures before reporting done.
+
+Output format:
+1. Test strategy (2-3 lines: what to test and why)
+2. Test files created/modified
+3. Test run results (pass/fail counts)
+4. Coverage gaps noted (if any)`,
+    debugger: `You are a debugging agent. Reproduce first, then diagnose, then fix minimally.
+
+Rules:
+- Reproduce the bug with a concrete test case or command before anything else.
+- Build a causal chain: symptom → hypothesis → evidence → root cause.
+- Make the minimal fix that addresses the root cause. Do NOT refactor during debugging.
+- Verify the fix resolves the symptom and doesn't break other tests.
+- If you can't reproduce, report what you tried and hypotheses.
+
+Output format:
+1. Reproduction steps + result
+2. Root cause analysis (causal chain)
+3. Fix applied (minimal diff)
+4. Verification (tests pass, symptom gone)`,
+    refactorer: `You are a refactoring agent. Improve code structure while preserving behavior exactly.
+
+Rules:
+- Run tests BEFORE refactoring to establish a green baseline.
+- Apply one refactoring pattern at a time (extract, inline, rename, move, simplify).
+- After each refactoring, run tests again to confirm no regressions.
+- Measure improvement: lines of code, cyclomatic complexity, duplication removed.
+- Never change behavior. If tests fail after refactoring, revert and try a different approach.
+
+Output format:
+1. Baseline test results
+2. Refactoring applied (pattern + files)
+3. Post-refactoring test results
+4. Metrics: before/after (LOC, complexity)`,
+    planner: `You are a planning agent. Break complex goals into concrete, actionable tasks.
+
+Rules:
+- Analyze the codebase structure before planning. Read key files to understand architecture.
+- Each task must be independently executable with clear inputs/outputs.
+- Identify dependencies between tasks (what blocks what).
+- Estimate effort per task (simple/moderate/complex) and assign to appropriate agent roles.
+- Flag risks and unknowns explicitly.
+
+Output format:
+1. Goal analysis (what's needed, key challenges)
+2. Task list with dependencies, roles, and estimates
+3. Execution order (respecting dependencies)
+4. Risks and mitigations`,
+};
+// ─── Prompt Builder ───
+/**
+ * Build an optimized system prompt for a sub-agent.
+ *
+ * Assembles role-specific instructions, optional language standards,
+ * framework context, and custom constraints into a single prompt.
+ *
+ * Target: <800 tokens for simple roles, <1200 for complex roles.
+ *
+ * @param config - Prompt configuration specifying role and context
+ * @returns Fully constructed system prompt string
+ */
+export function buildSubAgentPrompt(config) {
+    const sections = [];
+    // 1. Role-specific prompt (core instructions)
+    const rolePrompt = ROLE_PROMPTS[config.role];
+    if (!rolePrompt) {
+        // Fallback to coder if unknown role
+        sections.push(ROLE_PROMPTS.coder);
+    }
+    else {
+        sections.push(rolePrompt);
+    }
+    // 2. Language-specific coding standards (if detected)
+    if (config.language) {
+        const standards = getCodingStandards(config.language);
+        if (standards) {
+            sections.push(`## ${config.language} Standards\n${standards}`);
+        }
+    }
+    // 3. Framework context (brief)
+    if (config.framework) {
+        const frameworkNote = getFrameworkNote(config.framework);
+        if (frameworkNote) {
+            sections.push(`## Framework: ${config.framework}\n${frameworkNote}`);
+        }
+    }
+    // 4. Project context (if provided)
+    if (config.projectContext) {
+        sections.push(`## Project Context\n${config.projectContext}`);
+    }
+    // 5. Additional constraints
+    if (config.constraints && config.constraints.length > 0) {
+        sections.push(`## Additional Constraints\n${config.constraints.map((c) => `- ${c}`).join("\n")}`);
+    }
+    return sections.join("\n\n").trim();
+}
+/**
+ * Get the role-specific prompt template without additional context.
+ * Useful for inspecting or testing individual role prompts.
+ */
+export function getRolePrompt(role) {
+    return ROLE_PROMPTS[role] ?? ROLE_PROMPTS.coder;
+}
+/**
+ * Get all available sub-agent roles.
+ */
+export function getAvailableRoles() {
+    return Object.keys(ROLE_PROMPTS);
+}
+// ─── Framework Notes ───
+// Short notes (<100 tokens each) to orient the agent in a specific framework.
+function getFrameworkNote(framework) {
+    const normalized = framework.toLowerCase().replace(/[.\s]/g, "");
+    const notes = {
+        react: "Use functional components + hooks. Follow Rules of Hooks. Use key props in lists. Memoize expensive computations. Clean up effects.",
+        nextjs: "App Router: use server components by default, 'use client' only when needed. Use next/image, next/link. API routes in app/api/. Metadata exports for SEO.",
+        vue: "Composition API preferred. Use ref/reactive for state. defineProps/defineEmits for component contracts. v-model for two-way binding.",
+        svelte: "Use $: for reactive declarations. Bind with bind:value. Use #each with key. Dispatch custom events. Use stores for shared state.",
+        express: "Use middleware composition. Validate inputs with schema. Handle errors in centralized error middleware. Use async handlers with try-catch.",
+        fastify: "Use schema validation for routes. Register plugins properly. Use decorators for shared state. Async handlers are native.",
+        django: "Use class-based views for complex logic, function views for simple. Follow model-view-template. Use ORM querysets efficiently.",
+        flask: "Use blueprints for modularity. Application factory pattern. Use decorators for routes. Register error handlers.",
+    };
+    return notes[normalized] ?? null;
+}
+//# sourceMappingURL=sub-agent-prompts.js.map

package/dist/sub-agent-prompts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sub-agent-prompts.js","sourceRoot":"","sources":["../src/sub-agent-prompts.ts"],"names":[],"mappings":"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"}