@oss-scout/core 0.5.0 → 0.7.0

package/dist/core/slm-triage.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Optional SLM (small language model) pre-triage pass for vetted issues
+ * (oss-autopilot#1122).
+ *
+ * When the user has an Ollama instance running locally and a model
+ * configured via `slmTriageModel`, vetting can call out to that model
+ * for a structured classification of each candidate issue. The result
+ * is surfaced on `IssueCandidate.slmTriage` so consumers (autopilot
+ * agents, dashboard, vet-list output) can show the call up-front and
+ * skip the cost of reading every issue body manually.
+ *
+ * Design highlights:
+ * - **Fail open.** Any failure (no model configured, Ollama down,
+ *   timeout, malformed JSON, schema mismatch) returns `null`. Triage
+ *   must never block the rest of the vetting pipeline.
+ * - **Schema-enforced JSON.** Uses Ollama's `format` parameter so the
+ *   decoder produces JSON conformant to a fixed schema; eliminates the
+ *   "model returned partial JSON" failure mode that plagues prompt-only
+ *   structured-output schemes.
+ * - **15s timeout.** Local SLMs vary widely in latency; 15s covers
+ *   small-to-mid models on consumer hardware (Gemma 4 e4b, Qwen 3 4b).
+ *   Slower models simply produce `null` and don't block vetting.
+ */
+import type { TrackedIssue, LinkedPR } from "./schemas.js";
+/**
+ * Result of an SLM triage call. The same shape Ollama is constrained to
+ * produce via `format` schema enforcement.
+ */
+export interface SLMTriageResult {
+    /** Three buckets that match human triage decisions. */
+    decision: "pursue" | "investigate" | "skip";
+    /** How sure the model is. Surface in UI; don't gate on it server-side. */
+    confidence: "high" | "medium" | "low";
+    /** Short phrases (not sentences) explaining the decision. 1–3 entries. */
+    reasons: string[];
+    /** Model id that produced this result. Useful when comparing runs. */
+    modelVersion: string;
+}
+/** Inputs to a triage call. */
+export interface SLMTriageInput {
+    issue: Pick<TrackedIssue, "title" | "labels"> & {
+        body?: string;
+    };
+    linkedPRExists: boolean;
+}
+/** Runtime options for `triageWithSLM`. */
+export interface SLMTriageOptions {
+    /** Model id (e.g. `gemma4:e4b`). Empty/unset disables triage. */
+    model: string;
+    /** Override Ollama base URL. Defaults to `http://127.0.0.1:11434`. */
+    host?: string;
+    /** Override request timeout. */
+    timeoutMs?: number;
+    /** Override fetch implementation (for tests). */
+    fetchImpl?: typeof fetch;
+}
+/**
+ * Run an SLM triage classification. Returns `null` on any failure path
+ * — caller treats `null` as "no SLM signal available".
+ */
+export declare function triageWithSLM(input: SLMTriageInput, options: SLMTriageOptions): Promise<SLMTriageResult | null>;
+/**
+ * Adapter: build an `SLMTriageInput` from the standard scout types we
+ * carry through `vetIssue`. Centralizes the mapping so callers don't
+ * have to know about the prompt internals.
+ */
+export declare function buildTriageInput(args: {
+    issue: TrackedIssue & {
+        body?: string;
+    };
+    linkedPR: LinkedPR | null | undefined;
+}): SLMTriageInput;

package/dist/core/slm-triage.js

@@ -0,0 +1,135 @@
+/** Default Ollama HTTP endpoint when not overridden. */
+const DEFAULT_OLLAMA_HOST = "http://127.0.0.1:11434";
+/** Default per-call timeout. */
+const DEFAULT_TIMEOUT_MS = 15_000;
+/** Hard cap on issue body length we send to the model. */
+const MAX_BODY_CHARS = 2000;
+/** JSON schema enforced server-side by Ollama's `format` parameter. */
+const SLM_TRIAGE_SCHEMA = {
+    type: "object",
+    properties: {
+        decision: { type: "string", enum: ["pursue", "investigate", "skip"] },
+        confidence: { type: "string", enum: ["high", "medium", "low"] },
+        reasons: {
+            type: "array",
+            items: { type: "string" },
+            minItems: 1,
+            maxItems: 3,
+        },
+    },
+    required: ["decision", "confidence", "reasons"],
+};
+/** Build the user-message prompt from an issue. */
+function buildPrompt(input) {
+    const { issue, linkedPRExists } = input;
+    const body = (issue.body ?? "").slice(0, MAX_BODY_CHARS);
+    return [
+        "You triage open-source issues for an autonomous contribution agent.",
+        "Classify the issue into exactly one bucket:",
+        "- pursue: small, concrete bug or feature with clear acceptance; safe for an autonomous agent to attempt without further design input",
+        "- investigate: tractable but needs human reading first (ambiguous scope, design questions, recently-touched files)",
+        "- skip: not actionable autonomously (epic, creative, blocked, requires upstream change, requires infra)",
+        "",
+        "Return JSON only matching the provided schema. Reasons must be short phrases, not sentences. 1-3 reasons total.",
+        "",
+        "Issue:",
+        `Title: ${issue.title}`,
+        `Body: ${body}`,
+        `Labels: ${issue.labels.join(", ")}`,
+        `Linked PR exists: ${linkedPRExists}`,
+    ].join("\n");
+}
+/**
+ * Run an SLM triage classification. Returns `null` on any failure path
+ * — caller treats `null` as "no SLM signal available".
+ */
+export async function triageWithSLM(input, options) {
+    if (!options.model)
+        return null;
+    const host = options.host ?? DEFAULT_OLLAMA_HOST;
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    const fetchFn = options.fetchImpl ?? fetch;
+    let response;
+    try {
+        response = await fetchFn(`${host}/api/chat`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                model: options.model,
+                messages: [{ role: "user", content: buildPrompt(input) }],
+                stream: false,
+                format: SLM_TRIAGE_SCHEMA,
+                options: { temperature: 0.1 },
+            }),
+            signal: AbortSignal.timeout(timeoutMs),
+        });
+    }
+    catch {
+        // Connection refused, timeout, DNS error, etc.
+        return null;
+    }
+    if (!response.ok)
+        return null;
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch {
+        return null;
+    }
+    // Ollama `chat` returns { message: { content: string }, ... }.
+    const content = payload?.message
+        ?.content;
+    if (typeof content !== "string")
+        return null;
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return null;
+    }
+    if (!isValidTriageShape(parsed))
+        return null;
+    return {
+        decision: parsed.decision,
+        confidence: parsed.confidence,
+        reasons: parsed.reasons,
+        modelVersion: options.model,
+    };
+}
+/**
+ * Adapter: build an `SLMTriageInput` from the standard scout types we
+ * carry through `vetIssue`. Centralizes the mapping so callers don't
+ * have to know about the prompt internals.
+ */
+export function buildTriageInput(args) {
+    return {
+        issue: {
+            title: args.issue.title,
+            labels: args.issue.labels,
+            body: args.issue.body,
+        },
+        linkedPRExists: !!args.linkedPR,
+    };
+}
+function isValidTriageShape(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const v = value;
+    if (v.decision !== "pursue" &&
+        v.decision !== "investigate" &&
+        v.decision !== "skip")
+        return false;
+    if (v.confidence !== "high" &&
+        v.confidence !== "medium" &&
+        v.confidence !== "low")
+        return false;
+    if (!Array.isArray(v.reasons) ||
+        v.reasons.length === 0 ||
+        v.reasons.length > 3)
+        return false;
+    if (!v.reasons.every((r) => typeof r === "string"))
+        return false;
+    return true;
+}

package/dist/core/types.d.ts

@@ -2,7 +2,7 @@
  * Core types for oss-scout — ephemeral types that are never persisted.
  */
 import type { RepoSignals, TrackedIssue, IssueVettingResult, IssueScope, ScoutState, SearchStrategy } from "./schemas.js";
-export type { ProjectCategory, IssueScope, RepoSignals, RepoScore, StoredMergedPR, StoredClosedPR, ContributionGuidelines, IssueVettingResult, TrackedIssue, ScoutPreferences, SavedCandidate, ScoutState, SearchStrategy, } from "./schemas.js";
+export type { ProjectCategory, IssueScope, RepoSignals, RepoScore, StoredMergedPR, StoredClosedPR, ContributionGuidelines, IssueVettingResult, LinkedPR, TrackedIssue, ScoutPreferences, SavedCandidate, ScoutState, SearchStrategy, } from "./schemas.js";
 /** Health snapshot of a GitHub repository. */
 export interface ProjectHealth {
     repo: string;
@@ -20,11 +20,34 @@ export interface ProjectHealth {
 }
 /** Priority tier for issue search results. */
 export type SearchPriority = "merged_pr" | "starred" | "normal";
+/** Source file the anti-LLM policy match came from, or null when no file matched. */
+export type AntiLLMPolicySourceFile = "CONTRIBUTING.md" | "CODE_OF_CONDUCT.md" | "README.md";
+/** Result of scanning a repo's policy docs for anti-LLM/AI keywords. */
+export interface AntiLLMPolicyResult {
+    matched: boolean;
+    matchedKeywords: string[];
+    sourceFile: AntiLLMPolicySourceFile | null;
+}
+/**
+ * Optional SLM (small language model) pre-triage classification for an
+ * issue (oss-autopilot#1122). Populated when the user has configured
+ * `slmTriageModel` and a local Ollama instance is reachable. Always
+ * fail-open: any error path leaves this `null`.
+ */
+export interface SLMTriageSummary {
+    decision: "pursue" | "investigate" | "skip";
+    confidence: "high" | "medium" | "low";
+    reasons: string[];
+    modelVersion: string;
+}
 /** A fully vetted issue candidate with scoring. */
 export interface IssueCandidate {
     issue: TrackedIssue;
     vettingResult: IssueVettingResult;
     projectHealth: ProjectHealth;
+    antiLLMPolicy: AntiLLMPolicyResult;
+    /** SLM pre-triage result, or `null` when not configured / unavailable. */
+    slmTriage: SLMTriageSummary | null;
     recommendation: "approve" | "skip" | "needs_review";
     reasonsToSkip: string[];
     reasonsToApprove: string[];

package/dist/index.d.ts

@@ -15,9 +15,10 @@
  * @packageDocumentation
  */
 export { createScout, OssScout } from "./scout.js";
-export type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectHealth, SearchPriority, CheckResult, VetListOptions, VetListResult, VetListEntry, VetListSummary, } from "./core/types.js";
-export type { ScoutState, ScoutPreferences, RepoScore, RepoSignals, IssueVettingResult, ContributionGuidelines, TrackedIssue, IssueScope, ProjectCategory, StoredMergedPR, StoredClosedPR, StoredOpenPR, SearchStrategy, SkippedIssue, } from "./core/schemas.js";
+export type { ScoutConfig, SearchOptions, SearchResult, IssueCandidate, MergedPRRecord, ClosedPRRecord, OpenPRRecord, RepoScoreUpdate, ProjectHealth, SearchPriority, CheckResult, AntiLLMPolicyResult, AntiLLMPolicySourceFile, VetListOptions, VetListResult, VetListEntry, VetListSummary, } from "./core/types.js";
+export type { ScoutState, ScoutPreferences, RepoScore, RepoSignals, IssueVettingResult, LinkedPR, ContributionGuidelines, TrackedIssue, IssueScope, ProjectCategory, StoredMergedPR, StoredClosedPR, StoredOpenPR, SearchStrategy, SkippedIssue, } from "./core/schemas.js";
 export { ScoutStateSchema, ScoutPreferencesSchema, RepoScoreSchema, IssueScopeSchema, ProjectCategorySchema, SearchStrategySchema, SkippedIssueSchema, } from "./core/schemas.js";
 export { requireGitHubToken, getGitHubToken } from "./core/utils.js";
 export { IssueDiscovery } from "./core/issue-discovery.js";
 export { IssueVetter, type ScoutStateReader } from "./core/issue-vetting.js";
+export { scanForAntiLLMPolicy, ANTI_LLM_KEYWORDS, } from "./core/anti-llm-policy.js";

package/dist/index.js

@@ -23,3 +23,4 @@ export { requireGitHubToken, getGitHubToken } from "./core/utils.js";
 // Internal classes (for advanced use)
 export { IssueDiscovery } from "./core/issue-discovery.js";
 export { IssueVetter } from "./core/issue-vetting.js";
+export { scanForAntiLLMPolicy, ANTI_LLM_KEYWORDS, } from "./core/anti-llm-policy.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@oss-scout/core",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "description": "Personalized GitHub issue finder with multi-strategy search, deep vetting, and viability scoring — CLI, library, MCP server, and Claude Code plugin",
   "type": "module",
   "bin": {