memonaut 0.1.0 → 0.3.0

package/src/search.ts

@@ -70,6 +70,40 @@ export function quoteQuery(text: string): string {
 	return quoted.join(' ');
 }
 
+/**
+ * Which transcripts a query is allowed to see.
+ *
+ * Visibility is decided per THREAD, because a lineage can in principle span
+ * working directories; the lineage set is only a prefilter. Both the FTS and
+ * the regex path go through here, so `private` and the cwd/project filters
+ * cannot drift apart between them.
+ */
+export function visibleSets(
+	files: Map<number, FileRecord>,
+	query: Pick<SearchQuery, 'cwd' | 'project' | 'includePrivate'>,
+): {files: Set<number>; lineages: Set<number>; totalLineages: Set<number>} {
+	const cwdMatch = query.cwd && query.cwd.length ? matcher(query.cwd) : null;
+	const projectMatch =
+		query.project && query.project.length ? new Set(query.project) : null;
+	const visibleFiles = new Set<number>();
+	const visibleLineages = new Set<number>();
+	const totalLineages = new Set<number>();
+	for (const file of files.values()) {
+		if (file.lineage_id !== null) totalLineages.add(Number(file.lineage_id));
+		if (!query.includePrivate && file.private) continue;
+		if (cwdMatch && !cwdMatch(file.cwd)) continue;
+		if (projectMatch && !(file.project && projectMatch.has(file.project)))
+			continue;
+		visibleFiles.add(Number(file.id));
+		if (file.lineage_id !== null) visibleLineages.add(Number(file.lineage_id));
+	}
+	return {
+		files: visibleFiles,
+		lineages: visibleLineages,
+		totalLineages,
+	};
+}
+
 function inList(
 	column: string,
 	values: string[] | undefined,
@@ -109,25 +143,11 @@ export function search(
 	const threadLimit = query.threadLimit ?? 3;
 	const files = loadFiles(db);
 
-	// Visibility is decided per THREAD, because a lineage can in principle span
-	// working directories. The lineage set below is only a prefilter.
-	const cwdMatch = query.cwd && query.cwd.length ? matcher(query.cwd) : null;
-	const projectMatch =
-		query.project && query.project.length ? new Set(query.project) : null;
-	const visibleFiles = new Set<number>();
-	const visibleLineages = new Set<number>();
-	for (const file of files.values()) {
-		if (!query.includePrivate && file.private) continue;
-		if (cwdMatch && !cwdMatch(file.cwd)) continue;
-		if (projectMatch && !(file.project && projectMatch.has(file.project)))
-			continue;
-		visibleFiles.add(Number(file.id));
-		if (file.lineage_id !== null) visibleLineages.add(Number(file.lineage_id));
-	}
-
-	const totalLineages = new Set<number>();
-	for (const file of files.values())
-		if (file.lineage_id !== null) totalLineages.add(Number(file.lineage_id));
+	const {
+		files: visibleFiles,
+		lineages: visibleLineages,
+		totalLineages,
+	} = visibleSets(files, query);
 
 	const clauses: string[] = [];
 	const args: unknown[] = [];
@@ -259,16 +279,20 @@ export function search(
 	};
 }
 
-function buildHit(
-	row: RawHit,
-	kind: ChunkKind,
-	score: number,
+/**
+ * Fan one entry back out to every visible thread that carries it.
+ *
+ * Shared by the FTS and the regex path, because they must produce identical
+ * thread lists: an entry is stored once and `membership` is what turns it back
+ * into "the twelve threads that inherited this".
+ */
+export function collectThreads(
+	entryId: number,
 	memberStmt: ReturnType<DB['prepare']>,
 	files: Map<number, FileRecord>,
 	visibleFiles: Set<number>,
-	threadLimit: number,
-): SearchHit | null {
-	const members = memberStmt.all(row.entry_id) as unknown as Array<{
+): ThreadRef[] {
+	const members = memberStmt.all(entryId) as unknown as Array<{
 		file_id: number;
 		seq: number;
 	}>;
@@ -297,6 +321,24 @@ function buildHit(
 	threads.sort((a, b) =>
 		(b.lastActivity ?? '').localeCompare(a.lastActivity ?? ''),
 	);
+	return threads;
+}
+
+function buildHit(
+	row: RawHit,
+	kind: ChunkKind,
+	score: number,
+	memberStmt: ReturnType<DB['prepare']>,
+	files: Map<number, FileRecord>,
+	visibleFiles: Set<number>,
+	threadLimit: number,
+): SearchHit | null {
+	const threads = collectThreads(
+		Number(row.entry_id),
+		memberStmt,
+		files,
+		visibleFiles,
+	);
 	if (threads.length === 0) return null;
 
 	return {

package/src/skills.ts

@@ -0,0 +1,86 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import {resolvePackageResource} from './resources.js';
+
+/**
+ * Installing the agent skill that ships with this package.
+ *
+ * pi loads the skill itself from `memonaut-pi` (its `pi.skills` entry), so this command exists for
+ * every other agent: the skill is the same file, and `~/.agents/skills/<name>` is where agents that
+ * are not pi look for it. One directory, no fan-out to twenty agent-specific locations, and the
+ * report names every path written.
+ */
+
+export interface Skill {
+	name: string;
+	description: string;
+	from: string;
+}
+
+export type Scope = 'user' | 'project';
+
+/** Where skills live, by convention. `project` keeps them beside the code that needs them. */
+export function destinationFor(scope: Scope, cwd = process.cwd()): string {
+	return scope === 'user'
+		? path.join(os.homedir(), '.agents', 'skills')
+		: path.join(cwd, '.agents', 'skills');
+}
+
+export function skillsSource(): string | undefined {
+	return resolvePackageResource('skills/');
+}
+
+/** Name and description come from the SKILL.md front matter, so there is one source of truth. */
+export function availableSkills(): Skill[] {
+	const root = skillsSource();
+	if (!root) return [];
+	const skills: Skill[] = [];
+	for (const entry of fs.readdirSync(root, {withFileTypes: true})) {
+		if (!entry.isDirectory()) continue;
+		const manifest = path.join(root, entry.name, 'SKILL.md');
+		if (!fs.existsSync(manifest)) continue;
+		const text = fs.readFileSync(manifest, 'utf8');
+		skills.push({
+			name: /^name:\s*(.+)$/m.exec(text)?.[1]?.trim() ?? entry.name,
+			description: /^description:\s*(.+)$/m.exec(text)?.[1]?.trim() ?? '',
+			from: path.join(root, entry.name),
+		});
+	}
+	return skills.sort((a, b) => a.name.localeCompare(b.name));
+}
+
+export interface Installed {
+	name: string;
+	to: string;
+	replaced: boolean;
+}
+
+/**
+ * Copies rather than symlinks, so an installed skill survives `node_modules` being deleted.
+ *
+ * The cost is that upgrading the package does not upgrade the installed skill, which is why the
+ * report says `replaced` versus `installed`: a skill that is quietly stale is worse than one you
+ * know you have to refresh.
+ */
+export function installSkills(scope: Scope, cwd = process.cwd()): Installed[] {
+	const destination = destinationFor(scope, cwd);
+	const installed: Installed[] = [];
+	for (const skill of availableSkills()) {
+		const to = path.join(destination, skill.name);
+		const replaced = fs.existsSync(to);
+		if (replaced) fs.rmSync(to, {recursive: true, force: true});
+		fs.mkdirSync(destination, {recursive: true});
+		fs.cpSync(skill.from, to, {recursive: true});
+		installed.push({name: skill.name, to, replaced});
+	}
+	return installed;
+}
+
+export function isInstalled(
+	skill: Skill,
+	scope: Scope,
+	cwd = process.cwd(),
+): boolean {
+	return fs.existsSync(path.join(destinationFor(scope, cwd), skill.name));
+}