@robzilla1738/agentswarm 0.3.0 → 0.6.0

package/dist/searchcore.js

@@ -0,0 +1,244 @@
+"use strict";
+/**
+ * Native search intelligence, ported from the author's SearchKit project
+ * (~/Code/searchkit): canonical-URL dedup, source classification, quality
+ * ranking, and quotable-passage extraction. Pure string/URL processing —
+ * no external services or processes; the engines that feed it live in
+ * webtools.ts.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.queryTerms = queryTerms;
+exports.expandQueries = expandQueries;
+exports.reformulate = reformulate;
+exports.looksAcademic = looksAcademic;
+exports.canonicalizeUrl = canonicalizeUrl;
+exports.classifySource = classifySource;
+exports.freshnessBoost = freshnessBoost;
+exports.detectDate = detectDate;
+exports.selectPassages = selectPassages;
+exports.scorePage = scorePage;
+exports.resultQualityScore = resultQualityScore;
+exports.mergeCandidates = mergeCandidates;
+exports.passageBonus = passageBonus;
+exports.rankBonus = rankBonus;
+/** Lowercased alphanumeric query tokens, stopword-ish short tokens dropped. */
+function queryTerms(query) {
+    const m = query.toLowerCase().match(/[a-z0-9]+/g) || [];
+    return [...new Set(m.filter((t) => t.length > 2))];
+}
+/**
+ * Generate a few complementary query phrasings to widen source coverage in
+ * one search: the original, a stopword-stripped keyword core (different
+ * recall on most engines), and a docs/guide angle for question-shaped
+ * queries. Deterministic and low-noise — capped at `max`.
+ */
+function expandQueries(query, max = 3) {
+    const base = query.trim();
+    const out = [base];
+    const terms = queryTerms(query);
+    const core = terms.join(" ");
+    if (core && core.length > 4 && core !== base.toLowerCase())
+        out.push(core);
+    if (/^(how|what|why|when|which|where|who|is|are|can|does|do)\b/i.test(base) && terms.length) {
+        out.push(`${core} guide`);
+    }
+    const seen = new Set();
+    return out.map((q) => q.trim()).filter((q) => q && !seen.has(q.toLowerCase()) && seen.add(q.toLowerCase())).slice(0, max);
+}
+/**
+ * Fallback phrasing when a query returns nothing: strip quotes and search
+ * operators down to the top keyword terms. Returns "" when no useful
+ * simplification exists.
+ */
+function reformulate(query) {
+    const cleaned = query
+        .replace(/["'""'']/g, " ")
+        .replace(/\b(site|intitle|inurl|filetype):\S+/gi, " ");
+    const alt = queryTerms(cleaned).slice(0, 6).join(" ");
+    return alt && alt !== query.toLowerCase().trim() ? alt : "";
+}
+/** Queries that smell academic trigger the scholarly engines in deep mode. */
+function looksAcademic(query) {
+    return /\b(paper|papers|study|studies|research|arxiv|doi|journal|peer.?review(ed)?|preprint|dataset|benchmark|survey|meta.?analysis|citations?|et al)\b/i.test(query);
+}
+const TRACKING_KEYS = new Set(["fbclid", "gclid", "mc_cid", "mc_eid"]);
+/** Stable canonical form for dedup: strip tracking params, www, trailing slash; sort the query. */
+function canonicalizeUrl(url) {
+    let u;
+    try {
+        u = new URL(url);
+    }
+    catch {
+        return url.toLowerCase();
+    }
+    const pairs = [...u.searchParams.entries()].filter(([k]) => !TRACKING_KEYS.has(k.toLowerCase()) && !k.toLowerCase().startsWith("utm_"));
+    pairs.sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    const query = pairs.length ? "?" + pairs.map(([k, v]) => `${k}=${v}`).join("&") : "";
+    const host = u.hostname.toLowerCase().replace(/^www\./, "");
+    let path = u.pathname || "/";
+    if (path !== "/")
+        path = path.replace(/\/+$/, "");
+    return `${u.protocol.toLowerCase()}//${host}${path}${query}`;
+}
+const ACADEMIC_HOSTS = [
+    "arxiv.org",
+    "doi.org",
+    "semanticscholar.org",
+    "ncbi.nlm.nih.gov",
+    "nature.com",
+    "sciencedirect.com",
+    "springer.com",
+    "link.springer.com",
+    "scholar.google.com",
+    "acm.org",
+    "ieee.org",
+];
+function classifySource(domain) {
+    const d = domain.toLowerCase();
+    if (d.endsWith(".gov") || d.endsWith(".mil"))
+        return "government";
+    if (d.endsWith(".edu"))
+        return "academic";
+    if (ACADEMIC_HOSTS.some((h) => d === h || d.endsWith("." + h)))
+        return "academic";
+    if (["twitter.com", "x.com", "reddit.com", "facebook.com"].some((s) => d.includes(s)))
+        return "social";
+    if (d.includes("news") || d.includes("reuters.com") || d.includes("apnews.com") || d.includes("bbc."))
+        return "news";
+    return "secondary";
+}
+/** Recency boost from an ISO date or bare year: +3 <1y, +2 <2y, +1 <5y, 0 older/undated. */
+function freshnessBoost(date, now = Date.now()) {
+    if (!date)
+        return 0;
+    const m = /^(\d{4})(?:-(\d{1,2})(?:-(\d{1,2}))?)?/.exec(date.trim());
+    if (!m)
+        return 0;
+    const t = Date.UTC(Number(m[1]), m[2] ? Number(m[2]) - 1 : 6, m[3] ? Number(m[3]) : 15);
+    const years = (now - t) / 31_557_600_000;
+    if (years < 1)
+        return 3;
+    if (years < 2)
+        return 2;
+    if (years < 5)
+        return 1;
+    return 0;
+}
+/** ISO date if present, else a bare year. */
+function detectDate(text) {
+    const iso = /\b(20\d{2}-\d{2}-\d{2})\b/.exec(text);
+    if (iso)
+        return iso[1];
+    const year = /\b(20\d{2})\b/.exec(text);
+    return year?.[1];
+}
+const WINDOW_WORDS = 60;
+const STRIDE = 30;
+/**
+ * Quotable passages: slide a 60-word window (stride 30) over the text and
+ * score each window by the fraction of query terms it contains. Deterministic
+ * lexical matching — no embeddings. Falls back to the lead window so a hit
+ * always carries something quotable.
+ */
+function selectPassages(text, query, maxPassages = 3) {
+    const body = text.trim();
+    if (!body)
+        return [];
+    const terms = queryTerms(query);
+    const tokens = [...body.matchAll(/\S+/g)];
+    if (!tokens.length)
+        return [];
+    const windows = [];
+    for (let i = 0; i < tokens.length; i += STRIDE) {
+        const slice = tokens.slice(i, i + WINDOW_WORDS);
+        const start = slice[0].index;
+        const last = slice[slice.length - 1];
+        const chunk = body.slice(start, last.index + last[0].length);
+        windows.push({ text: chunk, score: scoreChunk(chunk, terms) });
+        if (i + WINDOW_WORDS >= tokens.length)
+            break;
+    }
+    const scored = windows.filter((w) => w.score > 0).sort((a, b) => b.score - a.score);
+    const picked = (scored.length ? scored : windows).slice(0, maxPassages);
+    return picked.map((p) => ({ text: p.text, score: Math.round(p.score * 10_000) / 10_000 }));
+}
+function scoreChunk(chunk, terms) {
+    if (!terms.length)
+        return 0;
+    const lowered = chunk.toLowerCase();
+    let hits = 0;
+    for (const t of terms)
+        if (lowered.includes(t))
+            hits++;
+    return hits / terms.length;
+}
+/** Content-quality score for a fetched page (deep mode re-ranking). */
+function scorePage(page, terms) {
+    let score = 0;
+    const domain = page.domain.toLowerCase();
+    const url = page.url.toLowerCase();
+    const title = page.title.toLowerCase();
+    const type = classifySource(domain);
+    if (type === "primary" || type === "government" || type === "academic")
+        score += 5;
+    if (domain.includes("docs") || url.includes("docs") || title.includes("documentation"))
+        score += 5;
+    if (domain === "github.com" || domain === "gitlab.com")
+        score += 4;
+    if (["pypi.org", "npmjs.com", "rubygems.org"].includes(domain))
+        score -= 2;
+    score += freshnessBoost(page.date);
+    const lowered = page.text.toLowerCase();
+    for (const t of terms)
+        if (lowered.includes(t))
+            score += 1;
+    score += Math.min(page.text.length / 4000, 1);
+    return score;
+}
+const LOW_VALUE_SNIPPET = ["copy a direct link", "file metadata"];
+/** Pre-fetch quality score for one engine result (snippet-level signals only). */
+function resultQualityScore(c) {
+    const url = c.url.toLowerCase();
+    const title = c.title.toLowerCase();
+    const snippet = c.snippet.toLowerCase();
+    let score = Math.max(0, 20 - c.rank);
+    if (title.includes("official") || snippet.includes("official"))
+        score += 4;
+    if (title.includes("documentation") || snippet.includes("documentation") || url.includes("docs"))
+        score += 4;
+    if (url.includes("github.com") || url.includes("gitlab.com"))
+        score += 3;
+    if (c.engine === "arxiv" || c.engine === "crossref")
+        score += 3;
+    score += Math.min(2, freshnessBoost(c.date));
+    if (LOW_VALUE_SNIPPET.some((t) => snippet.includes(t)))
+        score -= 10;
+    return score;
+}
+/**
+ * Merge results from several engines: quality-rank, dedupe by canonical URL
+ * (first/best occurrence wins), cap at maxResults.
+ */
+function mergeCandidates(candidates, maxResults) {
+    const ranked = [...candidates].sort((a, b) => resultQualityScore(b) - resultQualityScore(a));
+    const seen = new Set();
+    const out = [];
+    for (const c of ranked) {
+        const key = canonicalizeUrl(c.url);
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push(c);
+        if (out.length >= maxResults)
+            break;
+    }
+    return out;
+}
+/** Best-passage bonus used in deep-mode composite scoring. */
+function passageBonus(passages) {
+    return passages.length ? passages[0].score * 3 : 0;
+}
+/** Engine-rank decay bonus used in composite scoring. */
+function rankBonus(rank, ceiling) {
+    return Math.max(0, ceiling - rank) * 0.2;
+}

package/dist/state.js

@@ -14,11 +14,15 @@ class RunState {
     taskOrder = [];
     agents = new Map();
     notes = [];
+    phases = [];
+    planExcerpt = "";
     conductorLog = [];
     operatorNotes = [];
     usageByModel = new Map();
     totalUsage = { ...types_1.ZERO_USAGE };
     cost = 0;
+    /** Sampled cumulative token spend over time (budget sparkline). */
+    budgetSeries = [];
     finalSummary;
     finalReportPath;
     lastSeq = 0;
@@ -29,10 +33,34 @@ class RunState {
     constructor(pricing = {}) {
         this.pricing = pricing;
     }
+    /** Sub-states for hierarchical teams, keyed by the owning task id. */
+    teams = new Map();
     apply(ev) {
         this.lastSeq = ev.seq;
         this.lastT = ev.t;
         this.updatedAt = ev.t;
+        // Team-stamped events reduce into their team's sub-state so a sub-swarm's
+        // hundred tasks never pollute the root task list. Usage still rolls up
+        // here — the run's budget/cost is one number.
+        const teamId = typeof ev.teamId === "string" ? ev.teamId : undefined;
+        if (teamId) {
+            let team = this.teams.get(teamId);
+            if (!team) {
+                team = new RunState(this.pricing);
+                this.teams.set(teamId, team);
+            }
+            const { teamId: _omit, ...rest } = ev;
+            team.apply(rest);
+            if (ev.type === "usage") {
+                const u = ev.usage;
+                const model = ev.model ?? "unknown";
+                this.usageByModel.set(model, (0, types_1.addUsage)(this.usageByModel.get(model) ?? { ...types_1.ZERO_USAGE }, u));
+                this.totalUsage = (0, types_1.addUsage)(this.totalUsage, u);
+                this.cost += (0, types_1.usageCost)(u, this.pricing[model]);
+                this.pushBudgetPoint(ev.t);
+            }
+            return;
+        }
         switch (ev.type) {
             case "run.created": {
                 this.meta = ev.meta;
@@ -96,9 +124,23 @@ class RunState {
                     t.report = ev.report;
                     t.reportStatus = ev.status;
                     t.artifacts = ev.artifacts ?? t.artifacts;
+                    if (Array.isArray(ev.keyFacts))
+                        t.keyFacts = ev.keyFacts;
+                    if (Array.isArray(ev.openQuestions))
+                        t.openQuestions = ev.openQuestions;
+                    if (Array.isArray(ev.filesTouched))
+                        t.filesTouched = ev.filesTouched;
+                    if (Array.isArray(ev.sources))
+                        t.sources = ev.sources;
                 }
                 break;
             }
+            case "task.checkpoint": {
+                const t = this.tasks.get(ev.taskId);
+                if (t)
+                    t.lastCheckpoint = ev.summary;
+                break;
+            }
             case "verify.result": {
                 const t = this.tasks.get(ev.taskId);
                 if (t)
@@ -146,18 +188,37 @@ class RunState {
                 }
                 break;
             }
+            case "plan.updated":
+                this.planExcerpt = String(ev.excerpt ?? "");
+                break;
+            case "phase.set":
+                this.phases.push({
+                    t: ev.t,
+                    name: String(ev.name ?? ""),
+                    goal: ev.goal,
+                    exitCriteria: ev.exit_criteria,
+                });
+                break;
             case "note.added":
                 this.notes.push({
                     t: ev.t,
                     taskId: ev.taskId,
                     agentId: ev.agentId,
                     key: ev.key,
+                    kind: ev.kind,
                     text: ev.text,
+                    url: typeof ev.url === "string" ? ev.url : undefined,
                 });
                 // Reduced state is held live by the hub and the resume seed — keep
-                // only the tail that digests/views actually use.
-                if (this.notes.length > 1000)
-                    this.notes.splice(0, this.notes.length - 1000);
+                // only the tail that digests/views actually use. Decisions and
+                // conflicts are never dropped: they anchor long-horizon coherence.
+                if (this.notes.length > 1000) {
+                    const keep = (n) => n.kind === "decision" || n.kind === "conflict";
+                    const pinned = this.notes.filter(keep);
+                    const rest = this.notes.filter((n) => !keep(n));
+                    rest.splice(0, rest.length - Math.max(0, 1000 - pinned.length));
+                    this.notes = [...pinned, ...rest].sort((a, b) => a.t - b.t);
+                }
                 break;
             case "conductor.say":
                 this.conductorLog.push({ t: ev.t, text: ev.text });
@@ -179,6 +240,7 @@ class RunState {
                 this.usageByModel.set(model, (0, types_1.addUsage)(this.usageByModel.get(model) ?? { ...types_1.ZERO_USAGE }, u));
                 this.totalUsage = (0, types_1.addUsage)(this.totalUsage, u);
                 this.cost += (0, types_1.usageCost)(u, this.pricing[model]);
+                this.pushBudgetPoint(ev.t);
                 break;
             }
             case "run.final":
@@ -187,6 +249,26 @@ class RunState {
                 break;
         }
     }
+    /**
+     * Sample the cumulative spend: a point per meaningful jump (≥0.5% of the
+     * budget cap, or 2k tokens unbounded), halving resolution past 600 points.
+     */
+    pushBudgetPoint(t) {
+        const tokens = this.totalUsage.promptTokens + this.totalUsage.completionTokens;
+        const cap = this.meta?.options?.maxTokens ?? 0;
+        const minStep = cap > 0 ? Math.max(2000, cap * 0.005) : 2000;
+        const last = this.budgetSeries[this.budgetSeries.length - 1];
+        if (last && tokens - last.tokens < minStep) {
+            last.t = t;
+            last.tokens = tokens;
+            last.cost = this.cost;
+            return;
+        }
+        this.budgetSeries.push({ t, tokens, cost: this.cost });
+        if (this.budgetSeries.length > 600) {
+            this.budgetSeries = this.budgetSeries.filter((_, i) => i % 2 === 0 || i === this.budgetSeries.length - 1);
+        }
+    }
     taskList() {
         return this.taskOrder.map((id) => this.tasks.get(id)).filter(Boolean);
     }