claude-alfred 0.1.0

package/dist/embedder-BshPIMrW.mjs

@@ -0,0 +1,215 @@
+#!/usr/bin/env node
+//#region src/embedder/voyage.ts
+const DEFAULT_API_URL = "https://api.voyageai.com/v1/embeddings";
+const DEFAULT_RERANK_URL = "https://api.voyageai.com/v1/rerank";
+const DEFAULT_MODEL = "voyage-4-large";
+const DEFAULT_RERANK_MODEL = "rerank-2.5";
+const DEFAULT_DIMS = 2048;
+function envOr(key, fallback) {
+	return process.env[key] || fallback;
+}
+function envIntOr(key, fallback) {
+	const v = process.env[key];
+	if (v) {
+		const n = parseInt(v, 10);
+		if (!isNaN(n) && n > 0) return n;
+	}
+	return fallback;
+}
+var VoyageError = class extends Error {
+	status;
+	detail;
+	raw;
+	errResp;
+	constructor(status, detail, raw, errResp) {
+		super(status === 401 || status === 403 ? `embedder: voyage returned ${status}: authentication failed (check VOYAGE_API_KEY)` : `embedder: voyage returned ${status}: ${detail}`);
+		this.status = status;
+		this.detail = detail;
+		this.raw = raw;
+		this.errResp = errResp;
+	}
+};
+const TRANSIENT_ERROR_TYPES = new Set([
+	"temporary_error",
+	"transient_error",
+	"overloaded",
+	"rate_limited",
+	"capacity_exceeded",
+	"service_unavailable"
+]);
+const TRANSIENT_MESSAGE_PATTERNS = [
+	"request to model",
+	"model is overloaded",
+	"temporarily",
+	"try again",
+	"service unavailable",
+	"internal server error",
+	"over capacity"
+];
+function isVoyageTransient(detail) {
+	const lower = detail.toLowerCase();
+	return TRANSIENT_MESSAGE_PATTERNS.some((p) => lower.includes(p));
+}
+function isVoyageTransientStructured(errResp) {
+	if (!errResp) return false;
+	if (errResp.type && TRANSIENT_ERROR_TYPES.has(errResp.type.toLowerCase())) return true;
+	if (errResp.code && TRANSIENT_ERROR_TYPES.has(errResp.code.toLowerCase())) return true;
+	return false;
+}
+async function retryVoyage(fn, signal) {
+	let lastErr;
+	for (let attempt = 0; attempt < 3; attempt++) {
+		if (attempt > 0) {
+			const delay = (1 << attempt) * 1e3;
+			await new Promise((resolve, reject) => {
+				const onAbort = () => {
+					clearTimeout(timer);
+					reject(signal.reason);
+				};
+				const timer = setTimeout(() => {
+					signal?.removeEventListener("abort", onAbort);
+					resolve();
+				}, delay);
+				signal?.addEventListener("abort", onAbort, { once: true });
+			});
+		}
+		try {
+			return await fn();
+		} catch (err) {
+			lastErr = err;
+			if (err instanceof VoyageError) {
+				if (err.status === 429 || err.status >= 500) continue;
+				if (err.status === 400 && (isVoyageTransient(err.detail) || isVoyageTransientStructured(err.errResp))) continue;
+				throw err;
+			}
+			continue;
+		}
+	}
+	throw lastErr;
+}
+var VoyageClient = class {
+	apiKey;
+	apiURL;
+	rerankURL;
+	model;
+	rerankModel;
+	dims;
+	constructor(apiKey) {
+		this.apiKey = apiKey;
+		this.apiURL = envOr("VOYAGE_API_URL", DEFAULT_API_URL);
+		this.rerankURL = envOr("VOYAGE_RERANK_API_URL", DEFAULT_RERANK_URL);
+		this.model = envOr("VOYAGE_MODEL", DEFAULT_MODEL);
+		this.rerankModel = envOr("VOYAGE_RERANK_MODEL", DEFAULT_RERANK_MODEL);
+		this.dims = envIntOr("VOYAGE_DIMS", DEFAULT_DIMS);
+	}
+	async embed(texts, inputType, signal) {
+		const payload = {
+			input: texts,
+			model: this.model,
+			input_type: inputType,
+			output_dimension: this.dims
+		};
+		return retryVoyage(() => this.doEmbed(payload, signal), signal);
+	}
+	async doEmbed(payload, signal) {
+		const resp = await fetch(this.apiURL, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"Authorization": `Bearer ${this.apiKey}`
+			},
+			body: JSON.stringify(payload),
+			signal: signal ?? AbortSignal.timeout(3e4)
+		});
+		if (!resp.ok) {
+			const raw = await resp.text().catch(() => "");
+			let errResp;
+			try {
+				const parsed = JSON.parse(raw);
+				if (parsed.detail) errResp = parsed;
+			} catch {}
+			throw new VoyageError(resp.status, errResp?.detail ?? raw, raw, errResp);
+		}
+		return (await resp.json()).data.map((d) => d.embedding);
+	}
+	async embedForSearch(query, signal) {
+		const vecs = await this.embed([query], "query", signal);
+		if (vecs.length === 0) throw new Error("embedder: no embeddings returned");
+		return vecs[0];
+	}
+	async embedForStorage(text, signal) {
+		const vecs = await this.embed([text], "document", signal);
+		if (vecs.length === 0) throw new Error("embedder: no embeddings returned");
+		return vecs[0];
+	}
+	async rerank(query, documents, topK, signal) {
+		const payload = {
+			query,
+			documents,
+			model: this.rerankModel,
+			top_k: topK,
+			return_documents: false
+		};
+		return retryVoyage(() => this.doRerank(payload, signal), signal);
+	}
+	async doRerank(payload, signal) {
+		const resp = await fetch(this.rerankURL, {
+			method: "POST",
+			headers: {
+				"Content-Type": "application/json",
+				"Authorization": `Bearer ${this.apiKey}`
+			},
+			body: JSON.stringify(payload),
+			signal: signal ?? AbortSignal.timeout(3e4)
+		});
+		if (!resp.ok) {
+			const raw = await resp.text().catch(() => "");
+			let errResp;
+			try {
+				const parsed = JSON.parse(raw);
+				if (parsed.detail) errResp = parsed;
+			} catch {}
+			throw new VoyageError(resp.status, errResp?.detail ?? raw, raw, errResp);
+		}
+		return (await resp.json()).data.map((d) => ({
+			index: d.index,
+			relevanceScore: d.relevance_score
+		}));
+	}
+};
+//#endregion
+//#region src/embedder/index.ts
+var Embedder = class Embedder {
+	client;
+	constructor(client) {
+		this.client = client;
+	}
+	static create() {
+		const apiKey = process.env["VOYAGE_API_KEY"];
+		if (!apiKey) throw new Error("VOYAGE_API_KEY is required but not set (get a key at https://dash.voyageai.com/)");
+		return new Embedder(new VoyageClient(apiKey));
+	}
+	get dims() {
+		return this.client.dims;
+	}
+	get model() {
+		return this.client.model;
+	}
+	async embedForSearch(query, signal) {
+		return this.client.embedForSearch(query, signal);
+	}
+	async embedForStorage(text, signal) {
+		return this.client.embedForStorage(text, signal);
+	}
+	async embedBatchForStorage(texts, signal) {
+		return this.client.embed(texts, "document", signal);
+	}
+	async validate(signal) {
+		await this.client.embed(["test"], "query", signal);
+	}
+	async rerank(query, documents, topK, signal) {
+		return this.client.rerank(query, documents, topK, signal);
+	}
+};
+//#endregion
+export { Embedder };

package/dist/epic-CdRKNGvP.mjs

@@ -0,0 +1,227 @@
+#!/usr/bin/env node
+import { n as VALID_SLUG, p as require_dist } from "./types-C3butmI8.mjs";
+import { mkdirSync, readFileSync, readdirSync, renameSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+//#region src/epic/index.ts
+var import_dist = require_dist();
+function epicsDir(projectPath) {
+	return join(projectPath, ".alfred", "epics");
+}
+function epicActivePath(projectPath) {
+	return join(epicsDir(projectPath), "_active.yaml");
+}
+const STATUS_DRAFT = "draft";
+const STATUS_IN_PROGRESS = "in-progress";
+const STATUS_COMPLETED = "completed";
+const STATUS_NOT_STARTED = "not-started";
+var EpicDir = class {
+	projectPath;
+	slug;
+	constructor(projectPath, slug) {
+		this.projectPath = projectPath;
+		this.slug = slug;
+	}
+	dir() {
+		return join(epicsDir(this.projectPath), this.slug);
+	}
+	epicPath() {
+		return join(this.dir(), "epic.yaml");
+	}
+	exists() {
+		try {
+			return statSync(this.dir()).isDirectory();
+		} catch {
+			return false;
+		}
+	}
+	read() {
+		return (0, import_dist.parse)(readFileSync(this.epicPath(), "utf-8"));
+	}
+	save(ep) {
+		const data = (0, import_dist.stringify)(ep);
+		const tmp = this.epicPath() + ".tmp";
+		writeFileSync(tmp, data);
+		renameSync(tmp, this.epicPath());
+	}
+	link(taskSlug, dependsOn) {
+		const ep = this.read();
+		const tasks = ep.tasks ?? [];
+		if (tasks.some((t) => t.slug === taskSlug)) throw new Error(`task "${taskSlug}" already linked to epic "${this.slug}"`);
+		const taskSet = new Set(tasks.map((t) => t.slug));
+		for (const dep of dependsOn) if (!taskSet.has(dep)) throw new Error(`dependency "${dep}" not found in epic "${this.slug}"`);
+		tasks.push({
+			slug: taskSlug,
+			status: STATUS_NOT_STARTED,
+			depends_on: dependsOn.length > 0 ? dependsOn : void 0
+		});
+		ep.tasks = tasks;
+		if (ep.status === "draft") ep.status = STATUS_IN_PROGRESS;
+		this.save(ep);
+	}
+	unlink(taskSlug) {
+		const ep = this.read();
+		const tasks = ep.tasks ?? [];
+		const idx = tasks.findIndex((t) => t.slug === taskSlug);
+		if (idx === -1) throw new Error(`task "${taskSlug}" not linked to epic "${this.slug}"`);
+		tasks.splice(idx, 1);
+		for (const t of tasks) if (t.depends_on) {
+			t.depends_on = t.depends_on.filter((d) => d !== taskSlug);
+			if (t.depends_on.length === 0) t.depends_on = void 0;
+		}
+		ep.tasks = tasks;
+		this.save(ep);
+	}
+	progress() {
+		const tasks = this.read().tasks ?? [];
+		return {
+			completed: tasks.filter((t) => t.status === STATUS_COMPLETED).length,
+			total: tasks.length
+		};
+	}
+};
+function initEpic(projectPath, slug, name) {
+	if (!VALID_SLUG.test(slug)) throw new Error(`invalid epic_slug "${slug}": must be lowercase alphanumeric with hyphens`);
+	const ed = new EpicDir(projectPath, slug);
+	if (ed.exists()) throw new Error(`epic already exists: ${slug}`);
+	mkdirSync(ed.dir(), { recursive: true });
+	const ep = {
+		name,
+		status: STATUS_DRAFT,
+		created_at: (/* @__PURE__ */ new Date()).toISOString()
+	};
+	ed.save(ep);
+	let state;
+	try {
+		state = readActiveEpics(projectPath);
+	} catch {
+		state = {};
+	}
+	const epics = state.epics ?? [];
+	if (!epics.includes(slug)) epics.push(slug);
+	state.epics = epics;
+	if (!state.primary) state.primary = slug;
+	writeActiveEpics(projectPath, state);
+	return ed;
+}
+function topologicalOrder(tasks) {
+	const inDeg = /* @__PURE__ */ new Map();
+	const adj = /* @__PURE__ */ new Map();
+	for (const t of tasks) {
+		if (!inDeg.has(t.slug)) inDeg.set(t.slug, 0);
+		for (const dep of t.depends_on ?? []) {
+			adj.set(dep, [...adj.get(dep) ?? [], t.slug]);
+			inDeg.set(t.slug, (inDeg.get(t.slug) ?? 0) + 1);
+		}
+	}
+	const queue = tasks.filter((t) => (inDeg.get(t.slug) ?? 0) === 0).map((t) => t.slug).sort();
+	const order = [];
+	while (queue.length > 0) {
+		const cur = queue.shift();
+		order.push(cur);
+		const neighbors = (adj.get(cur) ?? []).sort();
+		for (const next of neighbors) {
+			const deg = (inDeg.get(next) ?? 1) - 1;
+			inDeg.set(next, deg);
+			if (deg === 0) queue.push(next);
+		}
+	}
+	if (order.length !== tasks.length) throw new Error("dependency cycle detected");
+	return order;
+}
+function nextActionable(tasks) {
+	const statusMap = new Map(tasks.map((t) => [t.slug, t.status]));
+	return tasks.filter((t) => t.status === "not-started" && (t.depends_on ?? []).every((d) => statusMap.get(d) === "completed")).map((t) => t.slug);
+}
+function listAllEpics(projectPath) {
+	const dir = epicsDir(projectPath);
+	let entries;
+	try {
+		entries = readdirSync(dir);
+	} catch {
+		return [];
+	}
+	const summaries = [];
+	for (const entry of entries) {
+		if (entry.startsWith("_") || entry.startsWith(".")) continue;
+		try {
+			if (!statSync(join(dir, entry)).isDirectory()) continue;
+		} catch {
+			continue;
+		}
+		const ed = new EpicDir(projectPath, entry);
+		try {
+			const ep = ed.read();
+			const tasks = ep.tasks ?? [];
+			const completed = tasks.filter((t) => t.status === STATUS_COMPLETED).length;
+			summaries.push({
+				slug: entry,
+				name: ep.name,
+				status: ep.status,
+				completed,
+				total: tasks.length,
+				tasks
+			});
+		} catch {
+			continue;
+		}
+	}
+	return summaries;
+}
+function removeEpic(projectPath, slug) {
+	const ed = new EpicDir(projectPath, slug);
+	if (!ed.exists()) throw new Error(`epic "${slug}" not found`);
+	rmSync(ed.dir(), {
+		recursive: true,
+		force: true
+	});
+	try {
+		const state = readActiveEpics(projectPath);
+		state.epics = (state.epics ?? []).filter((e) => e !== slug);
+		if (state.primary === slug) state.primary = state.epics[0] ?? "";
+		writeActiveEpics(projectPath, state);
+	} catch {}
+}
+function unlinkTaskFromAllEpics(projectPath, taskSlug) {
+	for (const s of listAllEpics(projectPath)) if (s.tasks.some((t) => t.slug === taskSlug)) {
+		const ed = new EpicDir(projectPath, s.slug);
+		try {
+			ed.unlink(taskSlug);
+		} catch {}
+	}
+}
+function syncTaskStatus(projectPath, taskSlug, newStatus) {
+	for (const s of listAllEpics(projectPath)) {
+		const task = s.tasks.find((t) => t.slug === taskSlug);
+		if (!task) continue;
+		if (task.status === newStatus) return false;
+		const ed = new EpicDir(projectPath, s.slug);
+		try {
+			const ep = ed.read();
+			const tasks = ep.tasks ?? [];
+			const target = tasks.find((t) => t.slug === taskSlug);
+			if (target) target.status = newStatus;
+			const allCompleted = tasks.length > 0 && tasks.every((t) => t.status === "completed");
+			const anyInProgress = tasks.some((t) => t.status === STATUS_IN_PROGRESS);
+			if (allCompleted) ep.status = STATUS_COMPLETED;
+			else if (anyInProgress) ep.status = STATUS_IN_PROGRESS;
+			ed.save(ep);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	return false;
+}
+function readActiveEpics(projectPath) {
+	return (0, import_dist.parse)(readFileSync(epicActivePath(projectPath), "utf-8"));
+}
+function writeActiveEpics(projectPath, state) {
+	mkdirSync(epicsDir(projectPath), { recursive: true });
+	const data = (0, import_dist.stringify)(state);
+	const path = epicActivePath(projectPath);
+	const tmp = path + ".tmp";
+	writeFileSync(tmp, data);
+	renameSync(tmp, path);
+}
+//#endregion
+export { removeEpic as a, unlinkTaskFromAllEpics as c, nextActionable as i, initEpic as n, syncTaskStatus as o, listAllEpics as r, topologicalOrder as s, EpicDir as t };

package/dist/fts-BDdUbNfM.mjs

@@ -0,0 +1,195 @@
+#!/usr/bin/env node
+import { c as mapRow, r as getKnowledgeByIDs, u as searchKnowledgeKeyword } from "./knowledge-CCCixwb8.mjs";
+import { n as deserializeFloat32, t as cosineSimilarity } from "./vectors-DvuAqDeO.mjs";
+//#region src/store/fts.ts
+function subTypeHalfLife(subType) {
+	switch (subType) {
+		case "assumption": return 30;
+		case "inference": return 45;
+		case "general": return 60;
+		case "pattern": return 90;
+		case "decision": return 90;
+		case "rule": return 120;
+		default: return 60;
+	}
+}
+function subTypeBoost(subType) {
+	switch (subType) {
+		case "rule": return 2;
+		case "decision": return 1.5;
+		case "pattern": return 1.3;
+		default: return 1;
+	}
+}
+function searchKnowledgeFTS(store, query, limit) {
+	if (limit <= 0) limit = 10;
+	query = query.trim();
+	if (!query) return searchKnowledgeKeyword(store, "", limit);
+	const words = query.split(/\s+/);
+	let expanded;
+	try {
+		expanded = expandAliases(store, words);
+	} catch {
+		expanded = words;
+	}
+	const ftsTerms = [];
+	for (const w of expanded) {
+		const sanitized = sanitizeFTSTerm(w);
+		if (sanitized) ftsTerms.push(`"${sanitized}"`);
+	}
+	if (ftsTerms.length === 0) return searchKnowledgeKeyword(store, query, limit);
+	const ftsQuery = ftsTerms.join(" OR ");
+	let docs;
+	try {
+		docs = searchFTSKnowledge(store, ftsQuery, limit);
+	} catch {
+		return searchKnowledgeKeyword(store, query, limit);
+	}
+	if (docs.length < limit) {
+		const fuzzyDocs = fuzzySearchKnowledge(store, words, limit - docs.length, docs);
+		docs.push(...fuzzyDocs);
+	}
+	return docs;
+}
+function searchFTSKnowledge(store, ftsQuery, limit) {
+	return store.db.prepare(`
+    SELECT k.id, k.file_path, k.content_hash, k.title, k.content, k.sub_type,
+      k.project_remote, k.project_path, k.project_name, k.branch,
+      k.created_at, k.updated_at, k.hit_count, k.last_accessed, k.enabled,
+      bm25(knowledge_fts, 3.0, 1.0, 1.0) AS rank
+    FROM knowledge_fts f
+    JOIN knowledge_index k ON k.id = f.rowid
+    WHERE knowledge_fts MATCH ? AND k.enabled = 1
+    ORDER BY rank
+    LIMIT ?
+  `).all(ftsQuery, limit).map(mapRow);
+}
+function fuzzySearchKnowledge(store, queryWords, limit, exclude) {
+	if (limit <= 0) return [];
+	const excludeIds = new Set(exclude.map((d) => d.id));
+	const rows = store.db.prepare(`
+    SELECT id, file_path, content_hash, title, content, sub_type,
+           project_remote, project_path, project_name, branch,
+           created_at, updated_at, hit_count, last_accessed, enabled
+    FROM knowledge_index WHERE enabled = 1 LIMIT 500
+  `).all();
+	const docs = [];
+	for (const r of rows) {
+		if (excludeIds.has(r.id)) continue;
+		const targetWords = r.title.toLowerCase().split(/\s+/);
+		for (const qw of queryWords) {
+			let matched = false;
+			for (const tw of targetWords) if (fuzzyMatch(qw, tw)) {
+				matched = true;
+				break;
+			}
+			if (matched) {
+				docs.push(mapRow(r));
+				if (docs.length >= limit) return docs;
+				break;
+			}
+		}
+	}
+	return docs;
+}
+function detectKnowledgeConflicts(store, threshold = .7) {
+	const docs = store.db.prepare(`
+    SELECT e.source_id, e.vector FROM embeddings e
+    JOIN knowledge_index k ON k.id = e.source_id
+    WHERE e.source = 'knowledge' AND k.enabled = 1
+    LIMIT 1000
+  `).all().map((r) => ({
+		id: r.source_id,
+		vec: deserializeFloat32(r.vector)
+	}));
+	const conflicts = [];
+	for (let i = 0; i < docs.length; i++) for (let j = i + 1; j < docs.length; j++) {
+		if (docs[i].vec.length !== docs[j].vec.length) continue;
+		const sim = cosineSimilarity(docs[i].vec, docs[j].vec);
+		if (sim >= threshold) conflicts.push({
+			a: { id: docs[i].id },
+			b: { id: docs[j].id },
+			similarity: sim,
+			type: "potential_duplicate"
+		});
+	}
+	if (conflicts.length > 0) {
+		const hydrated = getKnowledgeByIDs(store, conflicts.flatMap((c) => [c.a.id, c.b.id]));
+		const docMap = new Map(hydrated.map((d) => [d.id, d]));
+		for (const conflict of conflicts) {
+			const a = docMap.get(conflict.a.id);
+			const b = docMap.get(conflict.b.id);
+			if (a) conflict.a = a;
+			if (b) conflict.b = b;
+			conflict.type = classifyConflict(conflict.a.content, conflict.b.content);
+		}
+	}
+	conflicts.sort((a, b) => b.similarity - a.similarity);
+	return conflicts;
+}
+function expandAliases(store, terms) {
+	if (terms.length === 0) return [];
+	const seen = new Set(terms.map((t) => t.toLowerCase()));
+	for (const t of terms) {
+		const lower = t.toLowerCase();
+		const aliasRows = store.db.prepare("SELECT alias FROM tag_aliases WHERE LOWER(tag) = ?").all(lower);
+		for (const r of aliasRows) seen.add(r.alias.toLowerCase());
+		const tagRows = store.db.prepare("SELECT tag FROM tag_aliases WHERE LOWER(alias) = ?").all(lower);
+		for (const r of tagRows) seen.add(r.tag.toLowerCase());
+	}
+	return [...seen];
+}
+function sanitizeFTSTerm(term) {
+	return term.replace(/["*^{}]/g, "");
+}
+const CONTRADICTION_PAIRS = [
+	["always", "never"],
+	["must", "must not"],
+	["use", "avoid"],
+	["enable", "disable"],
+	["allow", "deny"],
+	["required", "optional"],
+	["do", "don't"],
+	["add", "remove"],
+	["include", "exclude"]
+];
+function classifyConflict(contentA, contentB) {
+	const lowerA = contentA.toLowerCase();
+	const lowerB = contentB.toLowerCase();
+	for (const [w0, w1] of CONTRADICTION_PAIRS) {
+		const aHas0 = lowerA.includes(w0);
+		const aHas1 = lowerA.includes(w1);
+		const bHas0 = lowerB.includes(w0);
+		const bHas1 = lowerB.includes(w1);
+		if (aHas0 && bHas1 && !aHas1 || aHas1 && bHas0 && !bHas1) return "potential_contradiction";
+	}
+	return "potential_duplicate";
+}
+function levenshtein(a, b) {
+	const ra = [...a];
+	const rb = [...b];
+	const la = ra.length;
+	const lb = rb.length;
+	if (la === 0) return lb;
+	if (lb === 0) return la;
+	let prev = Array.from({ length: lb + 1 }, (_, j) => j);
+	for (let i = 1; i <= la; i++) {
+		const curr = new Array(lb + 1);
+		curr[0] = i;
+		for (let j = 1; j <= lb; j++) {
+			const cost = ra[i - 1] === rb[j - 1] ? 0 : 1;
+			curr[j] = Math.min(curr[j - 1] + 1, prev[j] + 1, prev[j - 1] + cost);
+		}
+		prev = curr;
+	}
+	return prev[lb];
+}
+function fuzzyMatch(query, target) {
+	const qLen = [...query].length;
+	if (qLen < 3) return false;
+	let maxDist = Math.min(2, Math.floor(qLen / 3));
+	if (maxDist === 0) maxDist = 1;
+	return levenshtein(query.toLowerCase(), target.toLowerCase()) <= maxDist;
+}
+//#endregion
+export { subTypeHalfLife as i, searchKnowledgeFTS as n, subTypeBoost as r, detectKnowledgeConflicts as t };