@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-EKLUBDBQ.js

@@ -0,0 +1,627 @@
+import {
+  evaluateComplexity
+} from "./chunk-NEQUQHOX.js";
+import {
+  GENERIC_FILE_TOKEN_PATTERN
+} from "./chunk-DJG5RIOR.js";
+import {
+  classifyIntent
+} from "./chunk-GI5M67YA.js";
+import {
+  stripBuildContextBlocks
+} from "./chunk-KUEWV2JH.js";
+
+// src/analytics/task-analysis.ts
+var DefaultExecutionProfileRegistry = class {
+  profiles = /* @__PURE__ */ new Map();
+  constructor(initialProfiles) {
+    for (const profile of initialProfiles) {
+      this.profiles.set(profile.id, profile);
+    }
+  }
+  get(id) {
+    return this.profiles.get(id);
+  }
+  list() {
+    return Array.from(this.profiles.values());
+  }
+};
+var DEFAULT_PROFILES = [
+  {
+    id: "code-strict",
+    description: "Strict code-change competitions with PR enforcement, FILE: compliance, and AI judge enabled.",
+    allowPRCreation: true,
+    requiresRealCode: true,
+    enforceFileSpec: true,
+    allowAIJudge: true,
+    flags: {
+      defaultForCI: true,
+      defaultForCompete: true
+    }
+  },
+  {
+    id: "hybrid",
+    description: "Mixed code + analysis competitions. PRs allowed, FILE: enforced, placeholder-only work tolerated with warnings.",
+    allowPRCreation: true,
+    requiresRealCode: false,
+    enforceFileSpec: true,
+    allowAIJudge: true,
+    flags: {
+      treatPlaceholderAsWarning: true,
+      defaultForExploratory: true
+    }
+  },
+  {
+    id: "analysis",
+    description: "Analysis, infra, or diagnostic runs. No code-change enforcement; FILE: specs are advisory only.",
+    allowPRCreation: false,
+    requiresRealCode: false,
+    enforceFileSpec: false,
+    allowAIJudge: false,
+    flags: {
+      defaultForFast: true,
+      infraMode: true
+    }
+  },
+  {
+    id: "fast-local",
+    description: "Fast local execution mode. No PR creation, branch-only workflow. Ideal for quick iterations and prototyping.",
+    allowPRCreation: false,
+    requiresRealCode: true,
+    enforceFileSpec: false,
+    allowAIJudge: false,
+    flags: {
+      defaultForFast: true
+    }
+  },
+  {
+    id: "review",
+    description: "Full review mode with PR creation. Thorough code review workflow. Ideal for production-ready changes.",
+    allowPRCreation: true,
+    requiresRealCode: true,
+    enforceFileSpec: true,
+    allowAIJudge: true,
+    flags: {
+      defaultForCompete: true
+    }
+  }
+];
+var defaultRegistry = new DefaultExecutionProfileRegistry(DEFAULT_PROFILES);
+function getExecutionProfileRegistry() {
+  return defaultRegistry;
+}
+function detectIntent(prompt) {
+  const result = classifyIntent(prompt);
+  switch (result.category) {
+    case "execute":
+      if (/\b(fix|bug|issue|error|regression)\b/i.test(prompt)) {
+        return "bugfix";
+      }
+      if (/\b(refactor|restructure|cleanup|optimize)\b/i.test(prompt)) {
+        return "refactor";
+      }
+      if (/\b(test|tests|testing|coverage|suite|spec)\b/i.test(prompt)) {
+        return "testing";
+      }
+      return "feature";
+    case "analyze":
+    case "review":
+      return "analysis";
+    case "test":
+      return "testing";
+    case "document":
+      return "documentation";
+    default: {
+      const text = prompt.toLowerCase();
+      if (/\b(config|configuration|settings|yml|yaml|env)\b/.test(text)) {
+        return "configuration";
+      }
+      return "unknown";
+    }
+  }
+}
+function mapProfileName(userProfileName) {
+  const mapping = {
+    speed: "fast-local",
+    quality: "review",
+    explore: "hybrid",
+    auto: "auto",
+    // Special case: handled by recommendation logic
+    // Direct mappings (user can use internal IDs directly)
+    "fast-local": "fast-local",
+    review: "review",
+    "code-strict": "code-strict",
+    hybrid: "hybrid",
+    analysis: "analysis"
+  };
+  return mapping[userProfileName.toLowerCase()];
+}
+function recommendProfile(intent, evaluation) {
+  const rationale = [];
+  let profile = "code-strict";
+  let confidence = 0.6;
+  const score = evaluation.complexityScore;
+  if (intent === "analysis") {
+    profile = "analysis";
+    confidence = 0.85;
+    rationale.push("Task intent indicates analysis/investigation.");
+  } else if (score >= 0.6) {
+    profile = "hybrid";
+    confidence = 0.8;
+    rationale.push("High complexity favors hybrid mode with flexible output.");
+  } else if (score <= 0.25 && intent === "configuration") {
+    profile = "analysis";
+    confidence = 0.7;
+    rationale.push("Low complexity configuration task.");
+  } else if (intent === "bugfix" || intent === "feature" || intent === "refactor") {
+    profile = score >= 0.4 ? "hybrid" : "code-strict";
+    confidence = score >= 0.4 ? 0.75 : 0.7;
+    rationale.push(
+      score >= 0.4 ? "Code-focused task with flexible workflow." : "Quick code change with strict code output."
+    );
+  } else if (score <= 0.3) {
+    profile = "code-strict";
+    confidence = 0.7;
+    rationale.push("Low complexity task favors strict code output.");
+  } else {
+    profile = "code-strict";
+    confidence = 0.65;
+    rationale.push("Defaulting to code-strict for quick iteration.");
+  }
+  return {
+    profile,
+    confidence,
+    rationale,
+    detectedOverrides: []
+  };
+}
+var GENERIC_FILE_PATTERN = new RegExp(GENERIC_FILE_TOKEN_PATTERN, "g");
+var COMMON_TLDS = /* @__PURE__ */ new Set([
+  "com",
+  "org",
+  "net",
+  "io",
+  "ai",
+  "co",
+  "dev",
+  "app",
+  "gov",
+  "edu",
+  "info",
+  "biz",
+  "me",
+  "us",
+  "uk",
+  "ca",
+  "xyz"
+]);
+function looksLikeDomainOrUrl(token) {
+  if (token.includes("://") || token.includes("@")) return true;
+  if (token.includes("/")) return false;
+  const ext = token.slice(token.lastIndexOf(".") + 1).toLowerCase();
+  return COMMON_TLDS.has(ext);
+}
+function normalizeDirectivePath(token) {
+  let t = token;
+  let changed = true;
+  while (changed) {
+    const stripped = t.replace(/^@/, "").replace(/^\.\//, "");
+    changed = stripped !== t;
+    t = stripped;
+  }
+  return t;
+}
+var WRAPPING_PAIRS = {
+  "(": ")",
+  "[": "]",
+  "{": "}",
+  "'": "'",
+  '"': '"',
+  "`": "`"
+};
+var QUOTE_CHARS = /* @__PURE__ */ new Set(["'", '"', "`"]);
+var PROSE_STOPWORDS = /* @__PURE__ */ new Set([
+  "the",
+  "a",
+  "an",
+  "to",
+  "of",
+  "in",
+  "on",
+  "for",
+  "with",
+  "but",
+  "is",
+  "are",
+  "be",
+  "it",
+  "this",
+  "that",
+  "please",
+  "update",
+  "add",
+  "fix",
+  "change",
+  "modify",
+  "refactor",
+  "implement"
+]);
+var LIST_CONNECTORS = /* @__PURE__ */ new Set(["and", "or", "&"]);
+function isBalancedBracketWrapper(token, open, close) {
+  const inner = token.slice(1, -1);
+  let depth = 0;
+  for (const ch of inner) {
+    if (ch === open) depth++;
+    else if (ch === close) {
+      depth--;
+      if (depth < 0) return false;
+    }
+  }
+  return depth === 0;
+}
+function trimTokenPunctuation(token) {
+  let t = token;
+  let changed = true;
+  while (changed && t.length >= 1) {
+    changed = false;
+    if (t.length >= 2) {
+      const open = t[0] ?? "";
+      const close = WRAPPING_PAIRS[open];
+      if (close && t.endsWith(close)) {
+        const inner = t.slice(1, -1);
+        let safeToUnwrap;
+        if (QUOTE_CHARS.has(open)) {
+          safeToUnwrap = true;
+        } else if (open === "[") {
+          safeToUnwrap = isBalancedBracketWrapper(t, open, close) && inner.includes("/");
+        } else {
+          safeToUnwrap = isBalancedBracketWrapper(t, open, close) && looksLikePathToken(inner);
+        }
+        if (safeToUnwrap) {
+          t = inner;
+          changed = true;
+          continue;
+        }
+      }
+    }
+    const stripped = t.replace(/[,;:.!?]+$/, "");
+    if (stripped !== t) {
+      t = stripped;
+      changed = true;
+    }
+  }
+  return t;
+}
+function looksLikePathToken(token) {
+  if (token.includes("/")) return true;
+  return /\.[A-Za-z][A-Za-z0-9]{0,7}$/.test(token);
+}
+function canonicalizeDirectivePath(token) {
+  return normalizeDirectivePath(trimTokenPunctuation(token.trim()));
+}
+function extractInlineDirectiveFiles(content, isPlural) {
+  const trimmed = content.trim();
+  if (!trimmed) return [];
+  const out = [];
+  const add = (raw) => {
+    const tok = trimTokenPunctuation(raw.trim());
+    if (tok) out.push(tok);
+  };
+  const stopwordKey = (tok) => tok.replace(/^[^A-Za-z0-9]+/, "").replace(/[^A-Za-z0-9]+$/, "").toLowerCase();
+  const inlineTokens = trimmed.split(/\s+/).filter(Boolean);
+  const hasProseStopword = inlineTokens.some((tok) => PROSE_STOPWORDS.has(stopwordKey(tok)));
+  const looksLikeList = trimmed.includes(",") || !hasProseStopword;
+  if (isPlural && looksLikeList) {
+    for (const token of trimmed.split(/[\s,]+/).filter(Boolean)) {
+      const key = stopwordKey(token);
+      if (LIST_CONNECTORS.has(key) || PROSE_STOPWORDS.has(key)) continue;
+      add(token);
+    }
+    return out;
+  }
+  if (trimmed.includes(",")) {
+    trimmed.split(",").forEach((segment, index) => {
+      const first = segment.trim().split(/\s+/).filter(Boolean)[0];
+      if (!first) return;
+      const cleaned = trimTokenPunctuation(first);
+      if (!cleaned) return;
+      if (index === 0 || looksLikePathToken(cleaned)) {
+        out.push(cleaned);
+      }
+    });
+    return out;
+  }
+  const tokens = trimmed.split(/\s+/).filter(Boolean);
+  tokens.forEach((token, index) => {
+    const cleaned = trimTokenPunctuation(token);
+    if (!cleaned) return;
+    if (index === 0 || looksLikePathToken(cleaned)) {
+      out.push(cleaned);
+    }
+  });
+  return out;
+}
+function detectRoutingSignals(prompt, linePreservingPrompt, contextFiles) {
+  const lineText = linePreservingPrompt ?? prompt;
+  const TRUE_COMPARISON_PATTERNS = [
+    /\bcompare(?:d|s|ing)?\b/i,
+    /\bcomparison(s)?\b/i,
+    /\bbenchmark(?:s|ed|ing)?\b/i,
+    /\bversus\b/i,
+    /\bvs\.?\b/i,
+    /\btrade-?offs?\b/i,
+    /\bpros?\s+(?:and|&)\s+cons?\b/i,
+    /\badvantages?\s+and\s+disadvantages?\b/i,
+    /\b(?:between|choose|decide|select)\b.{1,80}\b(?:and|or)\b/i
+  ];
+  const ANALYSIS_REVIEW_PATTERNS = [
+    /\breview(?:s|ed|ing)?\b/i,
+    /\banaly[sz](?:e|es|ed|ing|is)\b/i,
+    /\baudit(?:s|ed|ing)?\b/i,
+    /\bassess(?:ment|ments|es|ed|ing)?\b/i,
+    /\bevaluat(?:e|es|ed|ing|ion|ions)\b/i
+  ];
+  const SPEED_PATTERNS = [
+    /\bquick(?:ly)?\b/i,
+    /\bfaster\b/i,
+    /\bfast\b/i,
+    /\bspeed\s+up\b/i,
+    /\baccelerat(?:e|es|ed|ing)\b/i,
+    /\bparallel\b/i,
+    /\bsimultaneous(?:ly)?\b/i,
+    /\bbatch\b/i,
+    /\basap\b/i
+  ];
+  const CRITICAL_PATTERNS = [
+    /\bp0\b/i,
+    /\bp1\b/i,
+    /\bsev0\b/i,
+    /\bsev1\b/i,
+    /\bsevere\b/i,
+    /\bcritical\b/i,
+    /\burgent\b/i,
+    /\bproduction outage\b/i,
+    /\bsecurity incident\b/i,
+    /\bbreach\b/i,
+    /\bcompliance\b/i,
+    /\bprivacy\b/i,
+    /\bblocking release\b/i,
+    /\bship blocker\b/i,
+    /\bhotfix\b/i
+  ];
+  const QUESTION_WORDS = [
+    "what",
+    "why",
+    "how",
+    "when",
+    "where",
+    "which",
+    "who",
+    "is",
+    "are",
+    "can",
+    "could",
+    "should",
+    "would",
+    "does",
+    "do",
+    "will",
+    "did"
+  ];
+  const trueComparisonIntent = TRUE_COMPARISON_PATTERNS.some((pattern) => pattern.test(prompt));
+  const analysisReviewIntentOnly = !trueComparisonIntent && ANALYSIS_REVIEW_PATTERNS.some((pattern) => pattern.test(prompt));
+  const compareIntent = trueComparisonIntent && !analysisReviewIntentOnly;
+  const speedIntent = SPEED_PATTERNS.some((pattern) => pattern.test(prompt));
+  const isCritical = CRITICAL_PATTERNS.some((pattern) => pattern.test(prompt));
+  const filesMentioned = [];
+  const seenFiles = /* @__PURE__ */ new Set();
+  const addFile = (raw, normalize = true) => {
+    const trimmed = raw?.trim();
+    if (!trimmed) return;
+    const file = normalize ? normalizeDirectivePath(trimmed) : trimmed;
+    if (!file || seenFiles.has(file)) return;
+    seenFiles.add(file);
+    filesMentioned.push(file);
+  };
+  if (contextFiles) {
+    for (const file of contextFiles) {
+      addFile(file, false);
+    }
+  }
+  for (const match of prompt.matchAll(GENERIC_FILE_PATTERN)) {
+    const candidate = match[1];
+    if (candidate && looksLikeDomainOrUrl(candidate)) continue;
+    addFile(candidate);
+  }
+  const features = [];
+  const BULLET_PATTERN = /(?:^|\n)[ \t]*[*-]\s+([^\n]+)/g;
+  const COLON_PATTERN = /:\s*([^\n]+)/g;
+  for (const match of prompt.matchAll(COLON_PATTERN)) {
+    const items = match[1]?.split(/,|\band\b|\bor\b/gi) ?? [];
+    for (const item of items) {
+      const trimmed = item.trim();
+      if (trimmed.length >= 3) {
+        features.push(trimmed);
+      }
+    }
+  }
+  for (const match of lineText.matchAll(BULLET_PATTERN)) {
+    const trimmed = match[1]?.trim() ?? "";
+    if (trimmed.length >= 3) {
+      features.push(trimmed);
+    }
+  }
+  const FILE_DIRECTIVE_HEADER = /^[ \t]*FILE(S)?:[ \t]*(.*)$/i;
+  const BLOCK_BULLET = /^[ \t]*[-*][ \t]+(\S.*)$/;
+  const BLOCK_BARE_PATH = /^[ \t]+(\S.*)$/;
+  let hasFileDirective = false;
+  const directiveLines = lineText.split("\n");
+  for (let i = 0; i < directiveLines.length; i++) {
+    const headerMatch = directiveLines[i]?.match(FILE_DIRECTIVE_HEADER);
+    if (!headerMatch) {
+      continue;
+    }
+    hasFileDirective = true;
+    const isPlural = Boolean(headerMatch[1]);
+    const inlineFiles = extractInlineDirectiveFiles(headerMatch[2] ?? "", isPlural);
+    for (const file of inlineFiles) {
+      addFile(file);
+    }
+    if (inlineFiles.length === 0) {
+      for (let j = i + 1; j < directiveLines.length; j++) {
+        const line = directiveLines[j] ?? "";
+        if (line.trim() === "") {
+          break;
+        }
+        const bulletMatch = line.match(BLOCK_BULLET);
+        const match = bulletMatch ?? line.match(BLOCK_BARE_PATH);
+        if (!match) {
+          break;
+        }
+        const contentTokens = match[1]?.trim().split(/[\s,]+/).filter(Boolean) ?? [];
+        const token = contentTokens[0] ? trimTokenPunctuation(contentTokens[0]) : "";
+        if (!token) {
+          break;
+        }
+        const acceptBare = contentTokens.length === 1 || looksLikePathToken(token);
+        if (bulletMatch || acceptBare) {
+          addFile(token);
+        } else {
+          break;
+        }
+        i = j;
+      }
+    }
+  }
+  let isQuestionAnswer = false;
+  if (!hasFileDirective) {
+    const normalized = prompt.trim().toLowerCase();
+    const firstWord = normalized.split(/\s+/)[0] || "";
+    isQuestionAnswer = QUESTION_WORDS.includes(firstWord);
+  }
+  const suggestsParallel = filesMentioned.length > 1 || features.length > 1;
+  return {
+    compareIntent,
+    speedIntent,
+    isCritical,
+    isQuestionAnswer,
+    filesMentioned,
+    features,
+    suggestsParallel
+  };
+}
+function analyzeTask(prompt, context) {
+  const analysisPrompt = stripBuildInjectedContext(prompt);
+  const lineAnchoredPrompt = stripBuildInjectedContext(prompt, { preserveNewlines: true });
+  const complexity = evaluateComplexity(analysisPrompt);
+  const intent = detectIntent(analysisPrompt);
+  const suggestedProfile = recommendProfile(intent, complexity);
+  const routing = detectRoutingSignals(analysisPrompt, lineAnchoredPrompt, context?.filesMentioned);
+  return {
+    prompt,
+    complexity,
+    intent,
+    suggestedProfile,
+    routing,
+    context
+  };
+}
+function stripBuildInjectedContext(prompt, options) {
+  if (!prompt) return "";
+  let text = String(prompt);
+  text = stripBuildContextBlocks(text);
+  const toolPolicySplit = text.split(/\n---\n\n/);
+  if (toolPolicySplit.length > 1 && /##\s*Tool Usage Policy/i.test(toolPolicySplit[0] ?? "")) {
+    text = toolPolicySplit.slice(1).join("\n---\n\n");
+  }
+  text = text.replace(/##\s+Recent Git History[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  text = text.replace(/##\s+Relevant Files[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  text = text.replace(/##\s+Architecture Context[\s\S]*?(?=\n##\s+|\n$)/gi, "");
+  text = text.replace(/(^|\n)\s*FILE TARGETS:\s*\n(?:\s*[-•]\s+[^\n]+\n?)+/gi, "\n");
+  if (options?.preserveNewlines) {
+    text = text.replace(/[^\S\n]+/g, " ").replace(/ *\n/g, "\n").trim();
+    return text;
+  }
+  text = text.replace(/\s+/g, " ").trim();
+  return text;
+}
+function resolveExecutionProfile(options, registry) {
+  const rationale = [];
+  const { requestedProfile, analysis, env } = options;
+  if (requestedProfile) {
+    if (requestedProfile.toLowerCase() === "auto") {
+      rationale.push("Auto profile selected, using task analysis recommendation.");
+      const recommended2 = registry.get(analysis.suggestedProfile.profile) ?? registry.get("fast-local") ?? registry.list()[0];
+      if (recommended2) {
+        rationale.push(
+          `Selected profile "${recommended2.id}" based on task analysis (intent=${analysis.intent}, complexity=${analysis.complexity.complexityScore.toFixed(
+            2
+          )}).`
+        );
+        return {
+          profile: recommended2,
+          rationale,
+          requestedProfile
+        };
+      }
+    }
+    const mappedProfileId = mapProfileName(requestedProfile);
+    if (mappedProfileId && mappedProfileId !== "auto") {
+      const explicitProfile2 = registry.get(mappedProfileId);
+      if (explicitProfile2) {
+        rationale.push(
+          `Using explicitly requested profile "${requestedProfile}" (mapped to "${mappedProfileId}").`
+        );
+        return {
+          profile: explicitProfile2,
+          rationale,
+          requestedProfile
+        };
+      }
+    }
+    const explicitProfile = registry.get(requestedProfile);
+    if (explicitProfile) {
+      rationale.push(`Using explicitly requested profile "${requestedProfile}".`);
+      return {
+        profile: explicitProfile,
+        rationale,
+        requestedProfile
+      };
+    }
+    rationale.push(
+      `Requested profile "${requestedProfile}" not found, falling back to recommendation.`
+    );
+  }
+  if (env?.isCI || env?.isProduction) {
+    const strictProfile = registry.get("code-strict");
+    if (strictProfile) {
+      rationale.push("CI/production environment detected, enforcing code-strict profile.");
+      return {
+        profile: strictProfile,
+        rationale
+      };
+    }
+  }
+  const recommended = registry.get(analysis.suggestedProfile.profile) ?? registry.get("fast-local") ?? registry.list()[0];
+  if (recommended) {
+    rationale.push(
+      `Selected profile "${recommended.id}" based on task analysis (intent=${analysis.intent}, complexity=${analysis.complexity.complexityScore.toFixed(
+        2
+      )}).`
+    );
+    return {
+      profile: recommended,
+      rationale
+    };
+  }
+  throw new Error("No execution profiles are registered.");
+}
+
+export {
+  getExecutionProfileRegistry,
+  looksLikeDomainOrUrl,
+  canonicalizeDirectivePath,
+  analyzeTask,
+  resolveExecutionProfile
+};
+//# sourceMappingURL=chunk-EKLUBDBQ.js.map