swarm-orchestrator 7.0.0-alpha.0

package/dist/src/task-classifier.js

@@ -0,0 +1,134 @@
+"use strict";
+// Deterministic goal-to-task-type classifier using keyword matching.
+// No LLM call: classification drives tier-based requirement filtering
+// so it must be fast, reproducible, and testable.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskClassifier = void 0;
+// Each pattern is a regex that matches whole-ish tokens in the goal prompt.
+// Word boundaries prevent "express" from matching inside "expression".
+const CATEGORY_PATTERNS = {
+    'api-backend': [
+        /\bexpress\b/i,
+        /\bfastapi\b/i,
+        /\bflask\b/i,
+        /\brest\b/i,
+        /\bapi\b/i,
+        /\bendpoints?\b/i,
+        /\broutes?\b/i,
+        /\bmiddleware\b/i,
+        /\bserver\b/i,
+        /\bbackend\b/i,
+        /\bdatabase\b/i,
+        /\b(?:GET|POST|PUT|DELETE|PATCH)\b/,
+        /\bport\b/i,
+        /\bcors\b/i,
+    ],
+    'frontend-web': [
+        /\bhtml\b/i,
+        /\bcss\b/i,
+        /\bbrowser[- ]based\b/i,
+        /\breact\b/i,
+        /\bvue\b/i,
+        /\bsvelte\b/i,
+        /\bangular\b/i,
+        /\bdashboard\b/i,
+        /\bpanel\b/i,
+        /\bcomponents?\b/i,
+        /\bresponsive\b/i,
+        /\baccessibility\b/i,
+        /\baria\b/i,
+        /\bdom\b/i,
+        /\bcanvas\b/i,
+        /\bsvg\b/i,
+        /\bui\b/i,
+        /\bfrontend\b/i,
+        /\bwebapp\b/i,
+        /\bweb\s+app\b/i,
+        /\blanding\s+page\b/i,
+        /\bforms?\b/i,
+        /\bmodal\b/i,
+    ],
+    'cli-tool': [
+        /\bcli\b/i,
+        /\bcommand\s+line\b/i,
+        /\bterminal\b/i,
+        /\bflags?\b/i,
+        /--\w+/,
+        /\barguments?\b/i,
+        /\bargv\b/i,
+        /\bstdin\b/i,
+        /\bstdout\b/i,
+        /\bpipes?\b/i,
+        /\bshell\b/i,
+        /\bbinary\b/i,
+        /\bbin\b/i,
+        /\bsubcommands?\b/i,
+    ],
+    'library-package': [
+        /\blibrary\b/i,
+        /\bpackage\b/i,
+        /\bsdk\b/i,
+        /\bnpm\s+package\b/i,
+        /\bpip\s+package\b/i,
+        /\bcrate\b/i,
+        /\bimportable\b/i,
+        /\breusable\b/i,
+        /\bpublishable\b/i,
+    ],
+};
+function matchCategory(prompt, category) {
+    const matched = [];
+    for (const pattern of CATEGORY_PATTERNS[category]) {
+        const match = prompt.match(pattern);
+        if (match) {
+            matched.push(match[0]);
+        }
+    }
+    return { category, keywords: matched, count: matched.length };
+}
+class TaskClassifier {
+    classify(goalPrompt) {
+        if (!goalPrompt || goalPrompt.trim().length === 0) {
+            return { taskType: 'full-stack', confidence: 'low', matchedKeywords: [] };
+        }
+        const categories = [
+            'api-backend', 'frontend-web', 'cli-tool', 'library-package'
+        ];
+        const matches = categories.map(cat => matchCategory(goalPrompt, cat));
+        const backendMatch = matches.find(m => m.category === 'api-backend');
+        const frontendMatch = matches.find(m => m.category === 'frontend-web');
+        // Full-stack: both backend and frontend have 2+ matches
+        if (backendMatch.count >= 2 && frontendMatch.count >= 2) {
+            const combined = [...backendMatch.keywords, ...frontendMatch.keywords];
+            return { taskType: 'full-stack', confidence: 'high', matchedKeywords: combined };
+        }
+        // Sort by match count descending
+        const sorted = [...matches].sort((a, b) => b.count - a.count);
+        const winner = sorted[0];
+        const runner = sorted[1];
+        // No category has 2+ matches: default to full-stack with low confidence
+        if (winner.count < 2) {
+            if (winner.count === 1) {
+                return { taskType: 'full-stack', confidence: 'low', matchedKeywords: winner.keywords };
+            }
+            return { taskType: 'full-stack', confidence: 'low', matchedKeywords: [] };
+        }
+        // Determine confidence based on separation from runner-up
+        let confidence;
+        if (winner.count >= 3 && runner.count < 2) {
+            confidence = 'high';
+        }
+        else if (winner.count >= 2) {
+            confidence = 'medium';
+        }
+        else {
+            confidence = 'low';
+        }
+        return {
+            taskType: winner.category,
+            confidence,
+            matchedKeywords: winner.keywords,
+        };
+    }
+}
+exports.TaskClassifier = TaskClassifier;

package/dist/src/test-command-discovery.js

@@ -0,0 +1,123 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.discoverTestCommand = discoverTestCommand;
+exports.renderVerifyCommandSection = renderVerifyCommandSection;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Discover the target project's full test command from its package.json.
+ *
+ * Reads `scripts.test` and combines it with the detected package manager
+ * (from pnpm-lock.yaml, yarn.lock, or package-lock.json) to produce the
+ * single command agents should run to verify their work.
+ *
+ * @param projectRoot absolute path to the target project
+ * @returns discovery result including the command and any fallback warning
+ */
+function discoverTestCommand(projectRoot) {
+    const packageManager = detectPackageManager(projectRoot);
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return {
+            command: `${packageManager} test`,
+            rawScript: undefined,
+            hasScript: false,
+            packageManager,
+            warning: `no package.json found at ${packageJsonPath}; falling back to "${packageManager} test"`,
+        };
+    }
+    let pkg;
+    try {
+        pkg = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    }
+    catch (err) {
+        return {
+            command: `${packageManager} test`,
+            rawScript: undefined,
+            hasScript: false,
+            packageManager,
+            warning: `failed to parse ${packageJsonPath}: ${err.message}; falling back to "${packageManager} test"`,
+        };
+    }
+    const rawScript = pkg.scripts?.test;
+    if (!rawScript || rawScript.trim() === '') {
+        return {
+            command: `${packageManager} test`,
+            rawScript: undefined,
+            hasScript: false,
+            packageManager,
+            warning: `no "test" script in ${packageJsonPath}; falling back to "${packageManager} test" (may fail if no test setup exists)`,
+        };
+    }
+    return {
+        command: `${packageManager} test`,
+        rawScript,
+        hasScript: true,
+        packageManager,
+        warning: undefined,
+    };
+}
+function detectPackageManager(projectRoot) {
+    if (fs.existsSync(path.join(projectRoot, 'pnpm-lock.yaml')))
+        return 'pnpm';
+    if (fs.existsSync(path.join(projectRoot, 'yarn.lock')))
+        return 'yarn';
+    return 'npm';
+}
+/**
+ * Render the prompt section that tells an agent how to verify its work.
+ *
+ * Every prompt-building path in the orchestrator must include this block so
+ * agents run the project's full test gate (lint + tests + types) rather
+ * than a subset runner like `npx vitest --run` that would skip lint/types.
+ */
+function renderVerifyCommandSection(discovery) {
+    const lines = [];
+    lines.push('Verify before committing (REQUIRED)');
+    lines.push('-----------------------------------');
+    lines.push(`Before committing, run \`${discovery.command}\` and verify it passes.`);
+    lines.push('Do not run individual test tools directly. Run the project\'s full test script.');
+    if (discovery.hasScript && discovery.rawScript) {
+        lines.push(`This project's "${discovery.command}" runs: ${discovery.rawScript}`);
+        lines.push('Running a subset (e.g. `npx vitest --run`) will miss lint and type checks and your commit may fail.');
+    }
+    else if (discovery.warning) {
+        lines.push(`WARNING: ${discovery.warning}`);
+        lines.push('If no real test gate exists, say so in your verification section rather than fabricating output.');
+    }
+    lines.push('');
+    return lines.join('\n');
+}

package/dist/src/text-similarity.js

@@ -0,0 +1,24 @@
+"use strict";
+/**
+ * Shared text similarity utilities.
+ * Extracted from knowledge-base.ts to eliminate the
+ * duplicate Levenshtein implementation.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.levenshtein = levenshtein;
+/**
+ * Standard Levenshtein distance between two strings.
+ * O(m*n) time and space where m and n are string lengths.
+ */
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, (_, i) => Array.from({ length: n + 1 }, (_, j) => (i === 0 ? j : j === 0 ? i : 0)));
+    for (let i = 1; i <= m; i++) {
+        for (let j = 1; j <= n; j++) {
+            dp[i][j] = a[i - 1] === b[j - 1]
+                ? dp[i - 1][j - 1]
+                : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+        }
+    }
+    return dp[m][n];
+}

package/dist/src/tier-maps.js

@@ -0,0 +1,158 @@
+"use strict";
+// Tier maps: per-task-type requirement classifications.
+// Pure data, no logic. Consumed by RequirementFilter to decide
+// which requirements get injected, recommended, or suppressed.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIER_MAPS = void 0;
+const API_BACKEND_ENFORCE = [
+    { id: 'security-headers', description: 'Security headers on HTTP responses (X-Content-Type-Options, X-Frame-Options, CSP minimum)', tier: 'enforce', category: 'security' },
+    { id: 'body-size-limit', description: 'Global request body size limit via middleware (e.g. express.json({ limit }), Starlette ContentSizeLimitMiddleware), not per-field max_length', tier: 'enforce', category: 'security' },
+    { id: 'param-sanitization', description: 'ID and route parameter validation before route logic (regex or schema)', tier: 'enforce', category: 'validation' },
+    { id: 'input-type-validation', description: 'Type checks on all input fields (reject non-string where string expected, etc.)', tier: 'enforce', category: 'validation' },
+    { id: 'input-length-validation', description: 'Max length enforcement on string inputs', tier: 'enforce', category: 'validation' },
+    { id: 'input-empty-validation', description: 'Empty and whitespace-only rejection on required fields', tier: 'enforce', category: 'validation' },
+    { id: 'error-hide-internals', description: 'Error handler that never leaks err.message or stack traces to clients', tier: 'enforce', category: 'security' },
+    { id: 'config-externalization', description: 'Environment-dependent values (PORT, DB paths, CORS origins, file paths) from env vars, not hardcoded', tier: 'enforce', category: 'structure' },
+    { id: 'endpoint-tests', description: 'Tests for every endpoint covering happy path and at least one error path', tier: 'enforce', category: 'testing' },
+    { id: 'validation-tests', description: 'Tests for every validation rule: positive (valid input accepted) and negative (invalid input rejected with correct status code and error shape) for each type check, length check, empty check, and schema constraint', tier: 'enforce', category: 'testing' },
+    { id: 'gitignore', description: '.gitignore present with node_modules, dist, .env at minimum', tier: 'enforce', category: 'structure' },
+    { id: 'package-json-complete', description: 'package.json with name, description, scripts (start, test, dev), engines', tier: 'enforce', category: 'structure' },
+];
+const API_BACKEND_RECOMMEND = [
+    { id: 'readme-api-docs', description: 'README with endpoint documentation and env var reference', tier: 'recommend', category: 'documentation' },
+    { id: 'dockerfile', description: 'Dockerfile for containerized deployment', tier: 'recommend', category: 'structure' },
+    { id: 'rate-limiting', description: 'Rate limiting middleware or configuration', tier: 'recommend', category: 'security' },
+    { id: 'health-endpoint-timestamp', description: 'Health endpoint returns a timestamp, not just { status: "ok" }', tier: 'recommend', category: 'resilience' },
+    { id: '404-unknown-routes', description: 'Catch-all handler for undefined routes returning JSON error', tier: 'recommend', category: 'resilience' },
+    { id: 'test-isolation', description: 'Tests use temp directories with cleanup, not shared state', tier: 'recommend', category: 'testing' },
+    { id: 'delete-returns-confirmation', description: 'DELETE endpoints return the deleted object or count, not empty 204', tier: 'recommend', category: 'structure' },
+];
+const API_BACKEND_SKIP = [
+    { id: 'audio-feedback', description: 'Any audio/sound features', tier: 'skip', category: 'polish' },
+    { id: 'favicon', description: 'Custom favicons', tier: 'skip', category: 'polish' },
+    { id: 'theme-color-meta', description: 'Theme color meta tags', tier: 'skip', category: 'polish' },
+    { id: 'css-custom-properties', description: 'Elaborate CSS variable systems', tier: 'skip', category: 'polish' },
+    { id: 'aria-attributes', description: 'ARIA labels (not relevant for APIs)', tier: 'skip', category: 'accessibility' },
+    { id: 'responsive-layout', description: 'Responsive CSS (not relevant for APIs)', tier: 'skip', category: 'accessibility' },
+    { id: 'skip-link', description: 'Skip navigation links (not relevant for APIs)', tier: 'skip', category: 'accessibility' },
+    { id: 'dark-mode', description: 'Color scheme support (not relevant for APIs)', tier: 'skip', category: 'polish' },
+];
+const FRONTEND_WEB_ENFORCE = [
+    { id: 'aria-interactive', description: 'ARIA labels on all interactive elements (buttons, inputs, links, toggles)', tier: 'enforce', category: 'accessibility' },
+    { id: 'keyboard-navigation', description: 'All interactive elements reachable and operable via keyboard', tier: 'enforce', category: 'accessibility' },
+    { id: 'focus-visible', description: ':focus-visible styles on all interactive elements', tier: 'enforce', category: 'accessibility' },
+    { id: 'semantic-html', description: 'Semantic landmarks (main, nav, header, section, article as appropriate)', tier: 'enforce', category: 'accessibility' },
+    { id: 'responsive-breakpoint', description: 'At least one responsive breakpoint for mobile', tier: 'enforce', category: 'accessibility' },
+    { id: 'error-states', description: 'Error state UI for failed operations (not just happy path)', tier: 'enforce', category: 'resilience' },
+    { id: 'loading-states', description: 'Loading indicators for async operations', tier: 'enforce', category: 'resilience' },
+    { id: 'empty-states', description: 'Empty state UI when no data exists', tier: 'enforce', category: 'resilience' },
+    { id: 'input-validation-frontend', description: 'Client-side validation on form inputs before submission', tier: 'enforce', category: 'validation' },
+    { id: 'component-tests', description: 'Tests for core UI logic (state changes, event handlers, data transformations)', tier: 'enforce', category: 'testing' },
+    { id: 'gitignore', description: '.gitignore present', tier: 'enforce', category: 'structure' },
+    { id: 'package-json-complete', description: 'package.json with name, description, scripts', tier: 'enforce', category: 'structure' },
+];
+const FRONTEND_WEB_RECOMMEND = [
+    { id: 'prefers-color-scheme', description: 'Dark mode via prefers-color-scheme media query', tier: 'recommend', category: 'accessibility' },
+    { id: 'prefers-reduced-motion', description: 'Reduced motion support for animations', tier: 'recommend', category: 'accessibility' },
+    { id: 'skip-link', description: 'Skip navigation link for screen readers', tier: 'recommend', category: 'accessibility' },
+    { id: 'meta-description', description: 'Meta description tag', tier: 'recommend', category: 'documentation' },
+    { id: 'readme', description: 'README with usage instructions', tier: 'recommend', category: 'documentation' },
+    { id: 'css-custom-properties', description: 'CSS custom properties for theming (colors, spacing at minimum)', tier: 'recommend', category: 'structure' },
+    { id: 'zero-dependencies', description: 'Prefer custom implementations over CDN dependencies where reasonable', tier: 'recommend', category: 'structure' },
+];
+const FRONTEND_WEB_SKIP = [
+    { id: 'audio-feedback', description: 'Web Audio API sounds', tier: 'skip', category: 'polish' },
+    { id: 'favicon-custom', description: 'Custom inline SVG favicon', tier: 'skip', category: 'polish' },
+    { id: 'theme-color-meta', description: 'Dual theme-color meta tags', tier: 'skip', category: 'polish' },
+    { id: 'elaborate-animations', description: 'Complex animation systems', tier: 'skip', category: 'polish' },
+    { id: 'security-headers', description: 'Security headers (not relevant for static frontends without a server)', tier: 'skip', category: 'security' },
+];
+const CLI_TOOL_ENFORCE = [
+    { id: 'arg-validation', description: 'Argument validation with clear, specific error messages including the invalid value', tier: 'enforce', category: 'validation' },
+    { id: 'help-flag', description: '--help / -h flag with usage documentation', tier: 'enforce', category: 'documentation' },
+    { id: 'missing-file-error', description: 'Graceful handling of missing files with specific path in error message', tier: 'enforce', category: 'resilience' },
+    { id: 'permission-error', description: 'Graceful handling of permission errors with specific message', tier: 'enforce', category: 'resilience' },
+    { id: 'exit-codes', description: 'Non-zero exit codes on errors (0 success, 1 user error, 2 system error)', tier: 'enforce', category: 'structure' },
+    { id: 'core-logic-tests', description: 'Tests for all core logic functions (parsers, transformers, validators)', tier: 'enforce', category: 'testing' },
+    { id: 'error-path-tests', description: 'Tests for all error conditions (missing file, bad input, permission denied)', tier: 'enforce', category: 'testing' },
+    { id: 'gitignore', description: '.gitignore present', tier: 'enforce', category: 'structure' },
+    { id: 'package-json-complete', description: 'package.json with name, description, bin field, engines', tier: 'enforce', category: 'structure' },
+];
+const CLI_TOOL_RECOMMEND = [
+    { id: 'short-flags', description: 'Short flag aliases (-h, -v, etc.) in addition to long forms', tier: 'recommend', category: 'structure' },
+    { id: 'readme-usage', description: 'README with usage examples and flag documentation', tier: 'recommend', category: 'documentation' },
+    { id: 'no-color-support', description: 'NO_COLOR env var and TTY detection for colored output', tier: 'recommend', category: 'resilience' },
+    { id: 'stdin-support', description: 'Read from stdin when no file argument provided (where applicable)', tier: 'recommend', category: 'structure' },
+    { id: 'config-env-vars', description: 'Configuration via environment variables where appropriate', tier: 'recommend', category: 'structure' },
+];
+const CLI_TOOL_SKIP = [
+    { id: 'aria-attributes', description: 'ARIA (not relevant)', tier: 'skip', category: 'accessibility' },
+    { id: 'responsive-layout', description: 'Responsive CSS (not relevant)', tier: 'skip', category: 'accessibility' },
+    { id: 'dark-mode', description: 'Browser dark mode (not relevant)', tier: 'skip', category: 'polish' },
+    { id: 'favicon', description: 'Favicons (not relevant)', tier: 'skip', category: 'polish' },
+    { id: 'audio-feedback', description: 'Audio (not relevant)', tier: 'skip', category: 'polish' },
+    { id: 'security-headers', description: 'HTTP security headers (not relevant)', tier: 'skip', category: 'security' },
+    { id: 'css-custom-properties', description: 'CSS variables (not relevant)', tier: 'skip', category: 'polish' },
+];
+const LIBRARY_PACKAGE_ENFORCE = [
+    { id: 'type-exports', description: 'All public API types exported and documented', tier: 'enforce', category: 'structure' },
+    { id: 'input-validation', description: 'Validate public function inputs with descriptive errors', tier: 'enforce', category: 'validation' },
+    { id: 'error-messages-specific', description: 'Error messages include the invalid value and expected format', tier: 'enforce', category: 'validation' },
+    { id: 'unit-tests-core', description: 'Unit tests for all exported functions covering happy path, edge cases, error conditions', tier: 'enforce', category: 'testing' },
+    { id: 'zero-side-effects', description: 'No side effects in library code (no console.log, no file writes, no network calls)', tier: 'enforce', category: 'structure' },
+    { id: 'gitignore', description: '.gitignore present', tier: 'enforce', category: 'structure' },
+    { id: 'package-json-complete', description: 'package.json with name, description, main/exports, types, engines, license', tier: 'enforce', category: 'structure' },
+];
+const LIBRARY_PACKAGE_RECOMMEND = [
+    { id: 'readme-api', description: 'README with API documentation and usage examples', tier: 'recommend', category: 'documentation' },
+    { id: 'jsdoc-public', description: 'JSDoc on all public exports', tier: 'recommend', category: 'documentation' },
+    { id: 'changelog', description: 'CHANGELOG.md', tier: 'recommend', category: 'documentation' },
+    { id: 'test-edge-cases', description: 'Tests for boundary values, empty inputs, type mismatches', tier: 'recommend', category: 'testing' },
+];
+const LIBRARY_PACKAGE_SKIP = [
+    { id: 'aria-attributes', description: 'ARIA (not relevant for libraries)', tier: 'skip', category: 'accessibility' },
+    { id: 'responsive-layout', description: 'Responsive CSS (not relevant for libraries)', tier: 'skip', category: 'accessibility' },
+    { id: 'dark-mode', description: 'Browser dark mode (not relevant for libraries)', tier: 'skip', category: 'polish' },
+    { id: 'favicon', description: 'Favicons (not relevant for libraries)', tier: 'skip', category: 'polish' },
+    { id: 'audio-feedback', description: 'Audio (not relevant for libraries)', tier: 'skip', category: 'polish' },
+    { id: 'security-headers', description: 'HTTP security headers (not relevant for libraries)', tier: 'skip', category: 'security' },
+    { id: 'css-custom-properties', description: 'CSS variables (not relevant for libraries)', tier: 'skip', category: 'polish' },
+    { id: 'skip-link', description: 'Skip navigation (not relevant for libraries)', tier: 'skip', category: 'accessibility' },
+    { id: 'theme-color-meta', description: 'Theme color meta tags (not relevant for libraries)', tier: 'skip', category: 'polish' },
+];
+// Build the full-stack map from backend + frontend.
+// Enforce: union of both. Recommend: union of both. Skip: only items both agree are irrelevant.
+function buildFullStackMap() {
+    const seen = new Set();
+    const result = [];
+    // Enforce: union of backend + frontend enforce lists, deduplicated by id
+    for (const req of [...API_BACKEND_ENFORCE, ...FRONTEND_WEB_ENFORCE]) {
+        if (!seen.has(req.id)) {
+            seen.add(req.id);
+            result.push(req);
+        }
+    }
+    // Recommend: union of backend + frontend recommend lists, deduplicated by id
+    for (const req of [...API_BACKEND_RECOMMEND, ...FRONTEND_WEB_RECOMMEND]) {
+        if (!seen.has(req.id)) {
+            seen.add(req.id);
+            result.push(req);
+        }
+    }
+    // Skip: only items that appear in BOTH skip lists (intersection by id)
+    const backendSkipIds = new Set(API_BACKEND_SKIP.map(r => r.id));
+    for (const req of FRONTEND_WEB_SKIP) {
+        if (backendSkipIds.has(req.id) && !seen.has(req.id)) {
+            seen.add(req.id);
+            result.push(req);
+        }
+    }
+    return result;
+}
+exports.TIER_MAPS = {
+    'api-backend': [...API_BACKEND_ENFORCE, ...API_BACKEND_RECOMMEND, ...API_BACKEND_SKIP],
+    'frontend-web': [...FRONTEND_WEB_ENFORCE, ...FRONTEND_WEB_RECOMMEND, ...FRONTEND_WEB_SKIP],
+    'cli-tool': [...CLI_TOOL_ENFORCE, ...CLI_TOOL_RECOMMEND, ...CLI_TOOL_SKIP],
+    'library-package': [...LIBRARY_PACKAGE_ENFORCE, ...LIBRARY_PACKAGE_RECOMMEND, ...LIBRARY_PACKAGE_SKIP],
+    'full-stack': buildFullStackMap(),
+};

package/dist/src/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Shared type definitions for the swarm conductor
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/url-shortener.js

@@ -0,0 +1,135 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.URLShortener = exports.StatisticsTracker = void 0;
+exports.validateURL = validateURL;
+/**
+ * In-memory URL shortener primitives with URL validation, base62 short codes, and hit statistics.
+ */
+const crypto_1 = require("crypto");
+const defaults_1 = require("./defaults");
+const BASE62_ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ';
+function validateURL(value, maxLength = defaults_1.DEFAULT_URL_MAX_LENGTH) {
+    if (typeof value !== 'string') {
+        return false;
+    }
+    const normalizedURL = value.trim();
+    if (normalizedURL.length === 0 || normalizedURL.length > maxLength) {
+        return false;
+    }
+    try {
+        const parsedURL = new URL(normalizedURL);
+        return parsedURL.protocol === 'http:' || parsedURL.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+class StatisticsTracker {
+    hitCounts = new Map();
+    recordHit(shortCode) {
+        const normalizedCode = shortCode.trim();
+        if (normalizedCode.length === 0) {
+            throw new Error('Short code is required.');
+        }
+        const nextCount = this.getHits(normalizedCode) + 1;
+        this.hitCounts.set(normalizedCode, nextCount);
+        return nextCount;
+    }
+    getHits(shortCode) {
+        return this.hitCounts.get(shortCode.trim()) ?? 0;
+    }
+    reset(shortCode) {
+        if (typeof shortCode === 'string') {
+            const normalizedCode = shortCode.trim();
+            if (normalizedCode.length === 0) {
+                throw new Error('Short code is required.');
+            }
+            this.hitCounts.delete(normalizedCode);
+            return;
+        }
+        this.hitCounts.clear();
+    }
+    snapshot() {
+        return Object.fromEntries(this.hitCounts.entries());
+    }
+}
+exports.StatisticsTracker = StatisticsTracker;
+class URLShortener {
+    shortToURL = new Map();
+    urlToShort = new Map();
+    maxURLLength;
+    codeMinLength;
+    statistics;
+    constructor(options = {}) {
+        this.maxURLLength = options.maxURLLength ?? defaults_1.DEFAULT_URL_MAX_LENGTH;
+        this.codeMinLength = options.codeMinLength ?? defaults_1.DEFAULT_SHORT_CODE_MIN_LENGTH;
+        this.statistics = new StatisticsTracker();
+    }
+    shorten(url) {
+        const normalizedURL = this.normalizeURL(url);
+        const existingCode = this.urlToShort.get(normalizedURL);
+        if (existingCode) {
+            return existingCode;
+        }
+        let attempt = 0;
+        while (true) {
+            const shortCode = this.generateShortCode(normalizedURL, attempt);
+            const existingURL = this.shortToURL.get(shortCode);
+            if (!existingURL) {
+                this.shortToURL.set(shortCode, normalizedURL);
+                this.urlToShort.set(normalizedURL, shortCode);
+                return shortCode;
+            }
+            if (existingURL === normalizedURL) {
+                this.urlToShort.set(normalizedURL, shortCode);
+                return shortCode;
+            }
+            attempt += 1;
+        }
+    }
+    resolve(shortCode) {
+        const normalizedCode = shortCode.trim();
+        if (normalizedCode.length === 0) {
+            throw new Error('Short code is required.');
+        }
+        const url = this.shortToURL.get(normalizedCode) ?? null;
+        if (url) {
+            this.statistics.recordHit(normalizedCode);
+        }
+        return url;
+    }
+    getHitCount(shortCode) {
+        return this.statistics.getHits(shortCode);
+    }
+    has(shortCode) {
+        return this.shortToURL.has(shortCode.trim());
+    }
+    normalizeURL(url) {
+        const normalizedURL = url.trim();
+        if (!validateURL(normalizedURL, this.maxURLLength)) {
+            throw new Error('A valid HTTP or HTTPS URL is required.');
+        }
+        return normalizedURL;
+    }
+    generateShortCode(url, attempt) {
+        const hashInput = attempt === 0 ? url : `${url}:${attempt}`;
+        const hashHex = (0, crypto_1.createHash)('sha256').update(hashInput).digest('hex').slice(0, 16);
+        const numericHash = BigInt(`0x${hashHex}`);
+        return this.encodeBase62(numericHash).padStart(this.codeMinLength, '0');
+    }
+    encodeBase62(value) {
+        if (value === 0n) {
+            return '0';
+        }
+        let remaining = value;
+        let encoded = '';
+        const radix = BigInt(BASE62_ALPHABET.length);
+        while (remaining > 0n) {
+            const index = Number(remaining % radix);
+            encoded = BASE62_ALPHABET[index] + encoded;
+            remaining /= radix;
+        }
+        return encoded;
+    }
+}
+exports.URLShortener = URLShortener;