@multileaf/ai-workflow 0.4.1 → 0.6.0

package/dist/recommendations.js

@@ -241,6 +241,32 @@ export function recommendCapabilities(profile) {
             : [];
     });
 }
+export async function rankRecommendations(items, profile, ranker) {
+    if (items.length === 0)
+        return { items: [], ranking: [], changedPositions: 0 };
+    const answers = await ranker(profile, items);
+    const ranking = [];
+    const relevanceById = new Map();
+    for (const item of items) {
+        const answer = answers[item.id];
+        const relevance = answer?.relevance !== undefined && Number.isFinite(answer.relevance)
+            ? answer.relevance
+            : undefined;
+        relevanceById.set(item.id, relevance);
+        if (relevance !== undefined)
+            ranking.push({
+                id: item.id,
+                relevance,
+                ...(answer?.confidence !== undefined ? { confidence: answer.confidence } : {}),
+            });
+    }
+    const ordered = [...items].sort((a, b) => (relevanceById.get(b.id) ?? -1) - (relevanceById.get(a.id) ?? -1));
+    let changedPositions = 0;
+    for (let index = 0; index < ordered.length; index += 1)
+        if (ordered[index].id !== items[index].id)
+            changedPositions += 1;
+    return { items: ordered, ranking, changedPositions };
+}
 export function resourcesForCapabilities(ids) {
     const normalizedIds = ids.map((id) => (id === "vitest-testing" ? "verification" : id));
     const selectedCapabilities = new Set(CATALOG.filter(({ id }) => normalizedIds.includes(id)).map(({ id }) => id));
@@ -252,9 +278,14 @@ export function resourcesForCapabilities(ids) {
         ...new Map(resources.map((resource) => [`${resource.type}/${resource.id}`, resource])).values(),
     ];
 }
-export function serializeRecommendations(items, selected = []) {
+export function serializeRecommendations(items, selected = [], ranking = []) {
+    const rankingById = new Map(ranking.map((entry) => [entry.id, entry]));
     return `schema: 1\nrecommendations:\n${items
-        .map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}\n    selected: ${selected.includes(item.id)}\n    requires: [${(item.requires ?? []).join(", ")}]\n    resources: [${item.resources.map(({ type, id }) => `${type}/${id}`).join(", ")}]\n    selected_resources: [${item.resources
+        .map((item) => `  - id: ${item.id}\n    provider: ${item.provider}\n    confidence: ${item.confidence}${rankingById.has(item.id)
+        ? `\n    decision_relevance: ${rankingById.get(item.id)?.relevance}${rankingById.get(item.id)?.confidence !== undefined
+            ? `\n    decision_confidence: ${rankingById.get(item.id)?.confidence}`
+            : ""}`
+        : ""}\n    selected: ${selected.includes(item.id)}\n    requires: [${(item.requires ?? []).join(", ")}]\n    resources: [${item.resources.map(({ type, id }) => `${type}/${id}`).join(", ")}]\n    selected_resources: [${item.resources
         .filter(({ type, id }) => selected.includes(`${type}/${id}`))
         .map(({ type, id }) => `${type}/${id}`)
         .join(", ")}]\n    evidence: [${item.evidence.map((evidence) => `"${evidence}"`).join(", ")}]\n    rationale: ${item.rationale}`)

package/dist/semantic.d.ts

@@ -5,6 +5,8 @@ export type SemanticConfig = {
     baseUrl: string;
     chunkChars: number;
     topK: number;
+    excludeLockfiles: boolean;
+    apiKeyEnv?: string;
 };
 export type SemanticIndexChunk = {
     file: string;
@@ -21,6 +23,17 @@ export type SemanticMatch = {
     score: number;
     excerpt: string;
 };
+export type RerankedMatch = SemanticMatch & {
+    rerankScore?: number;
+};
+export type RerankOutcome = {
+    matches: RerankedMatch[];
+    changedPositions: number;
+};
+export type DecisionReranker = (query: string, candidates: {
+    id: string;
+    text: string;
+}[]) => Promise<Record<string, number | undefined>>;
 export type EmbeddingProvider = {
     available(): Promise<boolean>;
     embed(texts: string[]): Promise<number[][]>;
@@ -28,14 +41,19 @@ export type EmbeddingProvider = {
 export declare const SEMANTIC_CONFIG_PATH = "semantic.yml";
 export declare const SEMANTIC_INDEX_PATH = "semantic/index.json";
 export declare const DEFAULT_SEMANTIC_CONFIG: SemanticConfig;
+export declare const SEMANTIC_LOCKFILE_NAMES: Set<string>;
+export declare function isExcludedIndexFile(file: string): boolean;
 export declare function parseSemanticMapping(raw: unknown): SemanticConfig;
 export declare function serializeSemanticConfig(config: SemanticConfig): string;
 export declare function loadSemanticConfig(fs: FileSystem, aiwPath: string): SemanticConfig | undefined;
 export declare function parseSemanticConfig(text: string): SemanticConfig;
-export declare function createOllamaEmbeddingProvider(config: SemanticConfig): EmbeddingProvider;
+type FetchLike = (url: string, init?: RequestInit) => Promise<Response>;
+export declare function createOllamaEmbeddingProvider(config: SemanticConfig, fetchImpl?: FetchLike, env?: Readonly<Record<string, string | undefined>>): EmbeddingProvider;
 export declare function chunkText(content: string, chunkChars: number): string[];
 export declare function cosineSimilarity(a: number[], b: number[]): number;
 export declare function buildSemanticIndex(files: string[], readContent: (file: string) => Promise<string | undefined>, provider: EmbeddingProvider, config: SemanticConfig): Promise<SemanticIndex>;
 export declare function serializeSemanticIndex(index: SemanticIndex): string;
 export declare function parseSemanticIndex(text: string): SemanticIndex;
 export declare function querySemanticIndex(index: SemanticIndex, query: string, provider: EmbeddingProvider, config: SemanticConfig): Promise<SemanticMatch[]>;
+export declare function rerankSemanticMatches(matches: SemanticMatch[], query: string, reranker: DecisionReranker): Promise<RerankOutcome>;
+export {};

package/dist/semantic.js

@@ -8,7 +8,28 @@ export const DEFAULT_SEMANTIC_CONFIG = {
     baseUrl: "http://localhost:11434",
     chunkChars: 1200,
     topK: 8,
+    excludeLockfiles: true,
 };
+export const SEMANTIC_LOCKFILE_NAMES = new Set([
+    "bun.lock",
+    "bun.lockb",
+    "cargo.lock",
+    "composer.lock",
+    "deno.lock",
+    "flake.lock",
+    "gemfile.lock",
+    "go.sum",
+    "npm-shrinkwrap.json",
+    "package-lock.json",
+    "pipfile.lock",
+    "pnpm-lock.yaml",
+    "poetry.lock",
+    "uv.lock",
+    "yarn.lock",
+]);
+export function isExcludedIndexFile(file) {
+    return SEMANTIC_LOCKFILE_NAMES.has(file.split("/").pop()?.toLowerCase() ?? "");
+}
 export function parseSemanticMapping(raw) {
     if (!raw || typeof raw !== "object")
         throw new Error("semantic must be a YAML mapping");
@@ -18,10 +39,18 @@ export function parseSemanticMapping(raw) {
     const baseUrl = raw2.baseUrl;
     const chunkChars = raw2.chunkChars;
     const topK = raw2.topK;
+    const rawExclude = raw2.excludeLockfiles;
+    const apiKeyEnv = raw2.apiKeyEnv;
     if (typeof enabled !== "boolean")
         throw new Error("semantic.enabled must be a boolean");
+    const excludeLockfiles = rawExclude === undefined ? true : rawExclude;
     if (!enabled)
-        return { ...DEFAULT_SEMANTIC_CONFIG, enabled: false };
+        return { ...DEFAULT_SEMANTIC_CONFIG, enabled: false, excludeLockfiles };
+    if (rawExclude !== undefined && typeof rawExclude !== "boolean")
+        throw new Error("semantic.excludeLockfiles must be a boolean");
+    if (apiKeyEnv !== undefined &&
+        (typeof apiKeyEnv !== "string" || !/^[A-Z_][A-Z0-9_]*$/.test(apiKeyEnv)))
+        throw new Error("semantic.apiKeyEnv must be an uppercase environment variable name");
     if (typeof model !== "string" || model.trim() === "")
         throw new Error("semantic.model must be a non-empty string when semantic mapping is enabled");
     if (typeof baseUrl !== "string" || !/^https?:\/\//i.test(baseUrl))
@@ -32,10 +61,18 @@ export function parseSemanticMapping(raw) {
         throw new Error("semantic.chunkChars must be an integer of at least 200");
     if (typeof parsedTopK !== "number" || !Number.isInteger(parsedTopK) || parsedTopK < 1)
         throw new Error("semantic.topK must be a positive integer");
-    return { enabled: true, model, baseUrl, chunkChars: parsedChunk, topK: parsedTopK };
+    return {
+        enabled: true,
+        model,
+        baseUrl,
+        chunkChars: parsedChunk,
+        topK: parsedTopK,
+        excludeLockfiles,
+        ...(apiKeyEnv ? { apiKeyEnv } : {}),
+    };
 }
 export function serializeSemanticConfig(config) {
-    return `semantic:\n  enabled: ${config.enabled}\n  model: ${config.model}\n  baseUrl: ${config.baseUrl}\n  chunkChars: ${config.chunkChars}\n  topK: ${config.topK}\n`;
+    return `semantic:\n  enabled: ${config.enabled}\n  model: ${config.model}\n  baseUrl: ${config.baseUrl}\n  chunkChars: ${config.chunkChars}\n  topK: ${config.topK}\n  excludeLockfiles: ${config.excludeLockfiles}${config.apiKeyEnv ? `\n  apiKeyEnv: ${config.apiKeyEnv}` : ""}\n`;
 }
 export function loadSemanticConfig(fs, aiwPath) {
     const settings = loadSettings(fs, aiwPath);
@@ -56,8 +93,45 @@ function parseSemanticDocument(text) {
 export function parseSemanticConfig(text) {
     return parseSemanticDocument(text);
 }
-export function createOllamaEmbeddingProvider(config) {
-    const fetchImpl = (url, init) => fetch(url, init);
+const EMBED_BATCH_SIZE = 64;
+export function createOllamaEmbeddingProvider(config, fetchImpl = (url, init) => fetch(url, init), env = process.env) {
+    const externalToken = config.apiKeyEnv ? env[config.apiKeyEnv] : undefined;
+    const isExternal = config.apiKeyEnv !== undefined;
+    const authHeaders = (extra = {}) => externalToken ? { ...extra, authorization: `Bearer ${externalToken}` } : extra;
+    if (isExternal)
+        return {
+            async available() {
+                try {
+                    const response = await fetchImpl(`${config.baseUrl}/v1/models`, {
+                        headers: authHeaders(),
+                    });
+                    return response.ok;
+                }
+                catch {
+                    return false;
+                }
+            },
+            async embed(texts) {
+                const vectors = [];
+                for (let offset = 0; offset < texts.length; offset += EMBED_BATCH_SIZE) {
+                    const batch = texts.slice(offset, offset + EMBED_BATCH_SIZE);
+                    const response = await fetchImpl(`${config.baseUrl}/v1/embeddings`, {
+                        method: "POST",
+                        headers: authHeaders({ "content-type": "application/json" }),
+                        body: JSON.stringify({ model: config.model, input: batch }),
+                    });
+                    if (!response.ok)
+                        throw new Error(`Embedding request failed for model ${config.model}`);
+                    const body = (await response.json());
+                    const rows = body.data ?? [];
+                    if (rows.length !== batch.length ||
+                        rows.some((row) => !Array.isArray(row.embedding) || row.embedding.some((v) => typeof v !== "number")))
+                        throw new Error(`Embedding model ${config.model} returned invalid vectors`);
+                    vectors.push(...rows.map((row) => row.embedding));
+                }
+                return vectors;
+            },
+        };
     return {
         async available() {
             try {
@@ -76,18 +150,21 @@ export function createOllamaEmbeddingProvider(config) {
         },
         async embed(texts) {
             const vectors = [];
-            for (const text of texts) {
-                const response = await fetchImpl(`${config.baseUrl}/api/embeddings`, {
+            for (let offset = 0; offset < texts.length; offset += EMBED_BATCH_SIZE) {
+                const batch = texts.slice(offset, offset + EMBED_BATCH_SIZE);
+                const response = await fetchImpl(`${config.baseUrl}/api/embed`, {
                     method: "POST",
                     headers: { "content-type": "application/json" },
-                    body: JSON.stringify({ model: config.model, prompt: text }),
+                    body: JSON.stringify({ model: config.model, input: batch }),
                 });
                 if (!response.ok)
                     throw new Error(`Embedding request failed for model ${config.model}`);
                 const body = (await response.json());
-                if (!Array.isArray(body.embedding) || body.embedding.some((v) => typeof v !== "number"))
-                    throw new Error(`Embedding model ${config.model} returned an invalid vector`);
-                vectors.push(body.embedding);
+                if (!Array.isArray(body.embeddings) ||
+                    body.embeddings.length !== batch.length ||
+                    body.embeddings.some((vector) => !Array.isArray(vector) || vector.some((v) => typeof v !== "number")))
+                    throw new Error(`Embedding model ${config.model} returned invalid vectors`);
+                vectors.push(...body.embeddings);
             }
             return vectors;
         },
@@ -127,6 +204,8 @@ export function cosineSimilarity(a, b) {
 export async function buildSemanticIndex(files, readContent, provider, config) {
     const entries = [];
     for (const file of files) {
+        if (config.excludeLockfiles && isExcludedIndexFile(file))
+            continue;
         const content = await readContent(file);
         if (content === undefined)
             continue;
@@ -173,3 +252,24 @@ export async function querySemanticIndex(index, query, provider, config) {
         .sort((a, b) => b.score - a.score)
         .slice(0, config.topK);
 }
+export async function rerankSemanticMatches(matches, query, reranker) {
+    if (matches.length === 0)
+        return { matches: [], changedPositions: 0 };
+    const candidates = matches.map((match, index) => ({
+        id: `match_${index}`,
+        text: `${match.file}\n${match.excerpt}`,
+    }));
+    const scores = await reranker(query, candidates);
+    const reranked = matches.map((match, index) => {
+        const rerankScore = scores[`match_${index}`];
+        return Number.isFinite(rerankScore)
+            ? { ...match, rerankScore: rerankScore }
+            : { ...match };
+    });
+    reranked.sort((a, b) => (b.rerankScore ?? b.score) - (a.rerankScore ?? a.score));
+    let changedPositions = 0;
+    for (let index = 0; index < reranked.length; index += 1)
+        if (reranked[index].file !== matches[index].file)
+            changedPositions += 1;
+    return { matches: reranked, changedPositions };
+}

package/dist/services.d.ts

@@ -1,12 +1,14 @@
 import type { ProjectProfile } from "./profile.js";
+import type { EmbeddingProvider } from "./semantic.js";
 import type { ProjectScan } from "./scanner.js";
 import type { CapabilityRecommendation } from "./recommendations.js";
-import type { Interpreter } from "./interpreter.js";
+import type { Interpreter, AiProvider } from "./interpreter.js";
 import type { CommandExecutor } from "./vercel-skills.js";
 import type { CommandResult, FileSystem } from "./types.js";
 import type { PackageSourceLoader } from "./providers.js";
 import type { PrivateRegistryClient } from "./team-configuration.js";
 import type { PolicyTracking } from "./policy-gate.js";
+import type { DecisionProvider } from "./decision.js";
 import type { TelemetryClient } from "./telemetry.js";
 import type { DashboardHandle } from "./dashboard.js";
 import type { AgentOrchestrator } from "./orchestration.js";
@@ -35,6 +37,9 @@ export interface WorkflowDependencies {
         start(root: string, port: number): Promise<DashboardHandle>;
     };
     orchestrator?: AgentOrchestrator;
+    embeddingProvider?: EmbeddingProvider;
+    aiProvider?: AiProvider;
+    decisionProvider?: DecisionProvider;
 }
 export interface WorkflowService {
     execute(args: string[], root: string, fs: FileSystem): Promise<CommandResult>;

package/dist/telemetry.d.ts

@@ -14,10 +14,18 @@ export interface TelemetryClient {
     record(event: TelemetryEvent): Promise<void>;
 }
 export declare const DEFAULT_TELEMETRY_CONFIG: TelemetryConfig;
+export declare const TELEMETRY_CONSENT_PROMPT = "Enable anonymous telemetry? Each event contains only the command name and its outcome (success or failure) - never arguments, file paths, or file contents. [y/N] ";
+export declare function offerTelemetryConsent(fs: FileSystem, aiwPath: string, answer: (question: string) => Promise<string>): Promise<boolean>;
 export declare function parseTelemetryMapping(raw: unknown): TelemetryConfig;
 export declare function serializeTelemetryMapping(config: TelemetryConfig): unknown;
 export declare function loadTelemetryConfig(fs: FileSystem, aiwPath: string): TelemetryConfig;
 export declare function parseTelemetryConfig(content: string): TelemetryConfig;
 export declare function serializeTelemetryConfig(config: TelemetryConfig): string;
 export declare function createTelemetryEvent(command: string | undefined, result: CommandResult, config: TelemetryConfig): TelemetryEvent | undefined;
+export declare const TELEMETRY_BUFFER_FILE = "telemetry-buffer.jsonl";
+export declare const TELEMETRY_BUFFER_CAP = 200;
+export declare function telemetryBufferPath(aiwPath: string): string;
+export declare function readTelemetryBuffer(fs: FileSystem, aiwPath: string): TelemetryEvent[];
+export declare function appendTelemetryBuffer(fs: FileSystem, aiwPath: string, event: TelemetryEvent): void;
+export declare function purgeTelemetryBuffer(fs: FileSystem, aiwPath: string): void;
 export declare function recordConfiguredTelemetry(fs: FileSystem, aiwPath: string, client: TelemetryClient | undefined, command: string | undefined, result: CommandResult): Promise<void>;

package/dist/telemetry.js

@@ -1,10 +1,25 @@
-import { loadSettings } from "./settings.js";
+import { loadSettings, saveSettingsSection } from "./settings.js";
 export const DEFAULT_TELEMETRY_CONFIG = {
     schema: 1,
     enabled: false,
     includeCommand: true,
     includeOutcome: true,
 };
+export const TELEMETRY_CONSENT_PROMPT = "Enable anonymous telemetry? Each event contains only the command name and its outcome (success or failure) - never arguments, file paths, or file contents. [y/N] ";
+export async function offerTelemetryConsent(fs, aiwPath, answer) {
+    const settings = loadSettings(fs, aiwPath);
+    if (settings !== undefined && "telemetry" in settings)
+        return loadTelemetryConfig(fs, aiwPath).enabled;
+    const response = (await answer(TELEMETRY_CONSENT_PROMPT)).trim().toLowerCase();
+    const enabled = response === "y" || response === "yes";
+    saveSettingsSection(fs, aiwPath, "telemetry", serializeTelemetryMapping({
+        schema: 1,
+        enabled,
+        includeCommand: true,
+        includeOutcome: true,
+    }));
+    return enabled;
+}
 const TELEMETRY_COMMANDS = new Set([
     "adr",
     "audit-package",
@@ -110,9 +125,54 @@ export function createTelemetryEvent(command, result, config) {
         ...(config.includeOutcome ? { outcome: result.exitCode === 0 ? "success" : "failure" } : {}),
     };
 }
+export const TELEMETRY_BUFFER_FILE = "telemetry-buffer.jsonl";
+export const TELEMETRY_BUFFER_CAP = 200;
+export function telemetryBufferPath(aiwPath) {
+    return `${aiwPath}/${TELEMETRY_BUFFER_FILE}`;
+}
+export function readTelemetryBuffer(fs, aiwPath) {
+    const path = telemetryBufferPath(aiwPath);
+    if (!fs.exists(path))
+        return [];
+    return fs
+        .read(path)
+        .split(/\r?\n/)
+        .filter((line) => line.trim().length > 0)
+        .map((line) => {
+        const parsed = JSON.parse(line);
+        if (parsed.schema !== 1)
+            throw new Error("Invalid buffered telemetry event");
+        return parsed;
+    });
+}
+export function appendTelemetryBuffer(fs, aiwPath, event) {
+    const buffered = [...readTelemetryBuffer(fs, aiwPath), event];
+    const rotated = buffered.slice(Math.max(0, buffered.length - TELEMETRY_BUFFER_CAP));
+    fs.write(telemetryBufferPath(aiwPath), `${rotated.map((item) => JSON.stringify(item)).join("\n")}\n`);
+}
+export function purgeTelemetryBuffer(fs, aiwPath) {
+    const path = telemetryBufferPath(aiwPath);
+    if (fs.exists(path) && fs.remove)
+        fs.remove(path);
+}
 export async function recordConfiguredTelemetry(fs, aiwPath, client, command, result) {
-    if (!client)
+    if (!client) {
+        try {
+            const config = loadTelemetryConfig(fs, aiwPath);
+            const settings = loadSettings(fs, aiwPath);
+            const configured = (settings !== undefined && "telemetry" in settings) ||
+                fs.exists(`${aiwPath}/telemetry.yml`);
+            if (configured) {
+                const event = createTelemetryEvent(command, result, config);
+                if (event)
+                    appendTelemetryBuffer(fs, aiwPath, event);
+            }
+        }
+        catch {
+            // Telemetry must never affect the requested workflow operation.
+        }
         return;
+    }
     try {
         const config = loadTelemetryConfig(fs, aiwPath);
         const settings = loadSettings(fs, aiwPath);

package/dist/workflow.d.ts

@@ -2,5 +2,3 @@ import type { CommandResult, FileSystem } from "./types.js";
 import type { WorkflowDependencies } from "./services.js";
 export type WorkflowServices = WorkflowDependencies;
 export declare function runCommand(args: string[], root: string, fs: FileSystem, services?: WorkflowServices): Promise<CommandResult>;
-export type ConfirmQuestion = (question: string) => Promise<string>;
-export declare function configureOptionalModels(fs: FileSystem, aiwPath: string, answer: ConfirmQuestion): Promise<string[]>;