@hassangameryt/freeflow 0.2.0 → 0.4.0

package/plugins/freeflow/router/dist/config.js

@@ -1,114 +0,0 @@
-import { isValidPostToolRoutingMode, validatePositiveIntegerThreshold } from "./router-contract.js";
-export const OUTPUT_ROUTER_SKILL_PATH = "plugins/freeflow/skills/output-router/SKILL.md";
-export const DEFAULT_VAULT_ROOT = "~/.cache/freeflow-router/vault";
-export const DEFAULT_POST_TOOL_ROUTING = "off";
-export const DEFAULT_VAULT_RETENTION = {
-    strategy: "ttl",
-    ttlDays: 7,
-};
-export const DEFAULT_ROUTER_THRESHOLDS = {
-    largeOutputBytes: 64_000,
-    largeOutputLines: 1_000,
-};
-export function createDefaultRouterConfig(options = {}) {
-    return {
-        postToolRouting: DEFAULT_POST_TOOL_ROUTING,
-        thresholds: { ...DEFAULT_ROUTER_THRESHOLDS },
-        vault: {
-            root: options.vaultRoot ?? DEFAULT_VAULT_ROOT,
-            retention: options.vaultRetention ?? DEFAULT_VAULT_RETENTION,
-        },
-    };
-}
-export function normalizeRouterConfig(input) {
-    const config = createDefaultRouterConfig();
-    const warnings = [];
-    if (input === undefined || input === null) {
-        return { config, warnings };
-    }
-    if (!isRecord(input)) {
-        return {
-            config,
-            warnings: ["outputRouter config must be an object; using built-in output router defaults."],
-        };
-    }
-    applyPostToolRouting(config, warnings, input.postToolRouting);
-    applyPositiveInteger(config.thresholds, warnings, input.largeOutputBytes, "largeOutputBytes");
-    applyPositiveInteger(config.thresholds, warnings, input.largeOutputLines, "largeOutputLines");
-    applyVaultRoot(config, warnings, input.vaultRoot);
-    applyVaultRetention(config, warnings, input.vaultRetentionDays);
-    applyHints(config, warnings, input.generatedPaths, input.noisyCommandHints);
-    return { config, warnings };
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function applyPostToolRouting(config, warnings, value) {
-    if (value === undefined) {
-        return;
-    }
-    if (isValidPostToolRoutingMode(value)) {
-        config.postToolRouting = value;
-        return;
-    }
-    warnings.push(`Invalid outputRouter.postToolRouting=${JSON.stringify(value)}; using ${DEFAULT_POST_TOOL_ROUTING}.`);
-}
-function applyPositiveInteger(thresholds, warnings, value, key) {
-    if (value === undefined) {
-        return;
-    }
-    if (validatePositiveIntegerThreshold(value, `outputRouter.${key}`).length === 0) {
-        thresholds[key] = value;
-        return;
-    }
-    warnings.push(`Invalid outputRouter.${key}=${JSON.stringify(value)}; using ${DEFAULT_ROUTER_THRESHOLDS[key]}.`);
-}
-function applyVaultRoot(config, warnings, value) {
-    if (value === undefined) {
-        return;
-    }
-    if (typeof value === "string" && value.trim().length > 0) {
-        config.vault.root = value;
-        return;
-    }
-    warnings.push(`Invalid outputRouter.vaultRoot=${JSON.stringify(value)}; using ${DEFAULT_VAULT_ROOT}.`);
-}
-function applyVaultRetention(config, warnings, value) {
-    if (value === undefined) {
-        return;
-    }
-    if (validatePositiveIntegerThreshold(value, "outputRouter.vaultRetentionDays").length === 0) {
-        config.vault.retention = { strategy: "ttl", ttlDays: value };
-        return;
-    }
-    warnings.push(`Invalid outputRouter.vaultRetentionDays=${JSON.stringify(value)}; using ${DEFAULT_VAULT_RETENTION.ttlDays}.`);
-}
-function applyHints(config, warnings, generatedPaths, noisyCommandHints) {
-    const hints = {};
-    if (generatedPaths !== undefined) {
-        const parsed = parseStringArray(generatedPaths, "generatedPaths", warnings);
-        if (parsed) {
-            hints.generatedPathGlobs = parsed;
-        }
-    }
-    if (noisyCommandHints !== undefined) {
-        const parsed = parseStringArray(noisyCommandHints, "noisyCommandHints", warnings);
-        if (parsed) {
-            hints.noisyCommandPatterns = parsed;
-        }
-    }
-    if (hints.generatedPathGlobs || hints.noisyCommandPatterns) {
-        config.hints = hints;
-    }
-}
-function parseStringArray(value, key, warnings) {
-    if (!Array.isArray(value)) {
-        warnings.push(`Invalid outputRouter.${key}; expected an array of strings.`);
-        return undefined;
-    }
-    if (!value.every((item) => typeof item === "string")) {
-        warnings.push(`Invalid outputRouter.${key}; expected an array of strings.`);
-        return undefined;
-    }
-    return value;
-}

package/plugins/freeflow/router/dist/evidence-range-selector.d.ts

@@ -1,22 +0,0 @@
-export interface LineRange {
-    start: number;
-    end: number;
-}
-export type EvidenceChunkKind = "section" | "symbol" | "window";
-export type EvidenceRangeMatchKind = "exact-phrase" | "coverage" | "best-line";
-export interface SelectEvidenceRangeForChunkOptions {
-    lines: readonly string[];
-    chunkRange: LineRange;
-    chunkKind: EvidenceChunkKind;
-    queryTokens: readonly string[];
-    normalizedQueryPhrase: string;
-    chunkHasExactPhrase: boolean;
-    defaultContextLines: number;
-    queryCoverageMaxLines: number;
-}
-export interface EvidenceRangeSelection {
-    range: LineRange;
-    anchorLine: number;
-    matchKind: EvidenceRangeMatchKind;
-}
-export declare function selectEvidenceRangeForChunk(options: SelectEvidenceRangeForChunkOptions): EvidenceRangeSelection;

package/plugins/freeflow/router/dist/evidence-range-selector.js

@@ -1,180 +0,0 @@
-export function selectEvidenceRangeForChunk(options) {
-    const exactRange = options.chunkHasExactPhrase ? exactPhraseRangeForChunk(options) : null;
-    const chunkLength = options.chunkRange.end - options.chunkRange.start + 1;
-    const anchorLineIndex = exactRange ? exactRange.start - 1 : bestLineIndexInChunk(options);
-    if (exactRange) {
-        return {
-            range: {
-                start: Math.max(options.chunkRange.start, exactRange.start - options.defaultContextLines),
-                end: Math.min(options.chunkRange.end, exactRange.end + options.defaultContextLines),
-            },
-            anchorLine: exactRange.start,
-            matchKind: "exact-phrase",
-        };
-    }
-    if (options.chunkKind === "symbol" || chunkLength <= options.defaultContextLines * 2 + 4) {
-        return {
-            range: options.chunkRange,
-            anchorLine: anchorLineIndex + 1,
-            matchKind: exactRange ? "exact-phrase" : "best-line",
-        };
-    }
-    const coverageRange = queryCoverageRangeForChunk(options);
-    if (coverageRange) {
-        return {
-            range: coverageRange,
-            anchorLine: coverageRange.start,
-            matchKind: "coverage",
-        };
-    }
-    return {
-        range: {
-            start: Math.max(options.chunkRange.start, anchorLineIndex + 1 - options.defaultContextLines),
-            end: Math.min(options.chunkRange.end, anchorLineIndex + 1 + options.defaultContextLines),
-        },
-        anchorLine: anchorLineIndex + 1,
-        matchKind: "best-line",
-    };
-}
-function exactPhraseRangeForChunk(options) {
-    if (options.normalizedQueryPhrase === "") {
-        return null;
-    }
-    for (let lineIndex = options.chunkRange.start - 1; lineIndex < options.chunkRange.end; lineIndex += 1) {
-        const line = options.lines[lineIndex] ?? "";
-        if (hasExactNormalizedPhrase(line, options.normalizedQueryPhrase)) {
-            return { start: lineIndex + 1, end: lineIndex + 1 };
-        }
-    }
-    for (let startIndex = options.chunkRange.start - 1; startIndex < options.chunkRange.end; startIndex += 1) {
-        let text = "";
-        for (let endIndex = startIndex; endIndex < options.chunkRange.end; endIndex += 1) {
-            const line = options.lines[endIndex] ?? "";
-            text = text === "" ? line : `${text}\n${line}`;
-            if (hasExactNormalizedPhrase(text, options.normalizedQueryPhrase)) {
-                return { start: startIndex + 1, end: endIndex + 1 };
-            }
-        }
-    }
-    return null;
-}
-function bestLineIndexInChunk(options) {
-    let bestIndex = options.chunkRange.start - 1;
-    let bestScore = 0;
-    for (let lineIndex = options.chunkRange.start - 1; lineIndex < options.chunkRange.end; lineIndex += 1) {
-        const line = options.lines[lineIndex] ?? "";
-        const score = scoreText(line, options.queryTokens) * 4 + (line.trimStart().startsWith("#") ? 2 : 0);
-        if (score > bestScore) {
-            bestIndex = lineIndex;
-            bestScore = score;
-        }
-    }
-    return bestIndex;
-}
-function queryCoverageRangeForChunk(options) {
-    if (options.chunkKind !== "section" || options.queryTokens.length < 2) {
-        return null;
-    }
-    const remainingTokens = new Set(options.queryTokens);
-    const matchingLines = [];
-    for (let lineIndex = options.chunkRange.start - 1; lineIndex < options.chunkRange.end; lineIndex += 1) {
-        const line = options.lines[lineIndex] ?? "";
-        const lineTokens = new Set(tokenizeForSearch(line));
-        let matchedLine = false;
-        for (const token of options.queryTokens) {
-            if (lineTokens.has(token)) {
-                remainingTokens.delete(token);
-                matchedLine = true;
-            }
-        }
-        if (matchedLine) {
-            matchingLines.push(lineIndex + 1);
-        }
-        if (remainingTokens.size === 0) {
-            break;
-        }
-    }
-    if (remainingTokens.size > 0 || matchingLines.length === 0) {
-        return null;
-    }
-    const start = Math.max(options.chunkRange.start, Math.min(...matchingLines) - options.defaultContextLines);
-    const end = Math.min(options.chunkRange.end, Math.max(...matchingLines) + options.defaultContextLines);
-    if (end - start + 1 > options.queryCoverageMaxLines) {
-        return null;
-    }
-    return { start, end };
-}
-function hasExactNormalizedPhrase(text, normalizedQueryPhrase) {
-    return normalizedQueryPhrase !== "" && normalizePhraseSequence(text).includes(normalizedQueryPhrase);
-}
-function normalizePhraseSequence(text) {
-    const tokens = tokenizeForPhrase(text);
-    return tokens.length >= 2 ? tokens.join(" ") : "";
-}
-function tokenizeForSearch(text) {
-    return text
-        .split(/[^A-Za-z0-9_./-]+/)
-        .flatMap((token) => expandedIdentifierTokens(token.trim()))
-        .filter((token) => token.length >= 2);
-}
-function tokenizeForPhrase(text) {
-    return tokenizeForSearch(text);
-}
-function scoreText(text, tokens) {
-    const lower = text.toLowerCase();
-    return tokens.reduce((score, token) => score + countOccurrences(lower, token), 0);
-}
-function countOccurrences(text, token) {
-    let count = 0;
-    let index = text.indexOf(token);
-    while (index !== -1) {
-        count += 1;
-        index = text.indexOf(token, index + token.length);
-    }
-    return count;
-}
-function expandedIdentifierTokens(token) {
-    if (!token) {
-        return [];
-    }
-    const lower = token.toLowerCase();
-    if (!needsIdentifierSplit(token)) {
-        return [lower];
-    }
-    const variants = new Set();
-    addTokenVariant(variants, lower);
-    for (const part of splitIdentifierToken(token)) {
-        addTokenVariant(variants, part.toLowerCase());
-    }
-    return Array.from(variants);
-}
-function addTokenVariant(variants, token) {
-    if (token) {
-        variants.add(token);
-    }
-}
-function needsIdentifierSplit(token) {
-    if (/[._/-]/.test(token)) {
-        return true;
-    }
-    for (let index = 1; index < token.length; index += 1) {
-        const previous = token.charCodeAt(index - 1);
-        const current = token.charCodeAt(index);
-        const next = index + 1 < token.length ? token.charCodeAt(index + 1) : 0;
-        const previousIsLowerOrDigit = (previous >= 97 && previous <= 122) || (previous >= 48 && previous <= 57);
-        const previousIsUpper = previous >= 65 && previous <= 90;
-        const currentIsUpper = current >= 65 && current <= 90;
-        const nextIsLower = next >= 97 && next <= 122;
-        if ((previousIsLowerOrDigit && currentIsUpper) || (previousIsUpper && currentIsUpper && nextIsLower)) {
-            return true;
-        }
-    }
-    return false;
-}
-function splitIdentifierToken(token) {
-    return token
-        .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
-        .replace(/([A-Z]+)([A-Z][a-z])/g, "$1 $2")
-        .split(/[._/\-\s]+/)
-        .filter((part) => part.length > 0);
-}

package/plugins/freeflow/router/dist/evidence-search.d.ts

@@ -1,25 +0,0 @@
-export interface EvidenceSearchLineRange {
-    start: number;
-    end: number;
-}
-export interface EvidenceSearchFile {
-    path: string;
-    lines: readonly string[];
-}
-export interface EvidenceSearchCandidate<TFile extends EvidenceSearchFile = EvidenceSearchFile> {
-    file: TFile;
-    lineIndex: number;
-    score: number;
-    reason: string;
-    range?: EvidenceSearchLineRange;
-    exactNormalizedPhrase?: string;
-}
-export interface SearchRepoEvidenceCandidatesOptions<TFile extends EvidenceSearchFile = EvidenceSearchFile> {
-    files: readonly TFile[];
-    query: string;
-    topK: number;
-    defaultContextLines?: number;
-    queryCoverageMaxLines?: number;
-}
-export declare function searchRepoEvidenceCandidates<TFile extends EvidenceSearchFile>(options: SearchRepoEvidenceCandidatesOptions<TFile>): EvidenceSearchCandidate<TFile>[];
-export declare function findBestLineForQuery(lines: readonly string[], query: string): number | null;