pi-soly 1.9.3 → 1.11.0

package/codemap.ts

@@ -0,0 +1,276 @@
+// =============================================================================
+// codemap.ts — Project layout map for the soly extension
+// =============================================================================
+//
+// Walks cwd once at session_start, builds a compact "## project layout" map
+// of top-level directories, key config files, and code file counts. Injected
+// into the system prompt so the model has immediate awareness of where things
+// live without having to `ls` its way around.
+//
+// Heuristics:
+//   - skip noise: node_modules, .git, dist, build, .soly, .next, out, target,
+//     coverage, .venv, __pycache__
+//   - depth: walk 2 levels deep by default (cwd → dirs → subdirs)
+//   - key files: package.json, tsconfig.json, README.md, Cargo.toml, go.mod,
+//     pyproject.toml, .env.example, Dockerfile, docker-compose.yml/yaml,
+//     Makefile, .github/workflows
+//   - code counts: count files by extension at each level
+// =============================================================================
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const IGNORE_DIRS = new Set([
+	"node_modules",
+	".git",
+	".soly",
+	"dist",
+	"build",
+	"out",
+	"target",
+	"coverage",
+	".next",
+	".nuxt",
+	".venv",
+	"venv",
+	"__pycache__",
+	".cache",
+	".parcel-cache",
+	".turbo",
+]);
+
+const KEY_FILES = new Set([
+	"package.json",
+	"tsconfig.json",
+	"tsconfig.base.json",
+	"jsconfig.json",
+	"README.md",
+	"README.rst",
+	"Cargo.toml",
+	"go.mod",
+	"pyproject.toml",
+	"setup.py",
+	"requirements.txt",
+	"Pipfile",
+	"Gemfile",
+	"pom.xml",
+	"build.gradle",
+	"build.sbt",
+	"Makefile",
+	"Dockerfile",
+	"docker-compose.yml",
+	"docker-compose.yaml",
+	".env.example",
+	".nvmrc",
+	".node-version",
+	".tool-versions",
+	".editorconfig",
+	".prettierrc",
+	".eslintrc",
+	".eslintrc.js",
+	".eslintrc.json",
+	"biome.json",
+	"vitest.config.ts",
+	"jest.config.js",
+	"jest.config.ts",
+	"vite.config.ts",
+	"webpack.config.js",
+	"rollup.config.js",
+	"index.html",
+	".github",
+]);
+
+const CODE_EXTS = new Set([
+	"ts", "tsx", "js", "jsx", "mjs", "cjs",
+	"py", "pyx",
+	"go",
+	"rs",
+	"java", "kt", "scala",
+	"rb",
+	"php",
+	"cs", "fs", "vb",
+	"swift", "m",
+	"c", "cc", "cpp", "h", "hpp",
+	"sh", "bash", "zsh",
+]);
+
+export interface CodeMap {
+	root: string;
+	topLevel: { dirs: string[]; files: string[] };
+	/** Sub-tree at depth 2: parent → children (dirs only, capped). */
+	tree: Map<string, string[]>;
+	/** Key files with brief summaries (first line). */
+	keyFiles: { relPath: string; summary: string }[];
+	/** Code file counts per top-level dir. */
+	codeCounts: Record<string, number>;
+	hasGithubWorkflows: boolean;
+}
+
+function summarizeKeyFile(absPath: string, maxLen = 100): string {
+	try {
+		const content = fs.readFileSync(absPath, "utf-8");
+		// First non-empty, non-frontmatter line
+		const lines = content.split(/\r?\n/);
+		let inFrontmatter = false;
+		for (const l of lines) {
+			const t = l.trim();
+			if (!t) continue;
+			if (t === "---") {
+				inFrontmatter = !inFrontmatter;
+				continue;
+			}
+			if (inFrontmatter) continue;
+			return t.slice(0, maxLen);
+		}
+		return "";
+	} catch {
+		return "";
+	}
+}
+
+function listChildren(dir: string): { dirs: string[]; files: string[] } {
+	try {
+		const entries = fs.readdirSync(dir, { withFileTypes: true });
+		const dirs: string[] = [];
+		const files: string[] = [];
+		for (const e of entries) {
+			if (e.name.startsWith(".") && e.name !== ".github") continue;
+			if (IGNORE_DIRS.has(e.name)) continue;
+			if (e.isDirectory()) dirs.push(e.name);
+			else if (e.isFile()) files.push(e.name);
+		}
+		dirs.sort();
+		files.sort();
+		return { dirs, files };
+	} catch {
+		return { dirs: [], files: [] };
+	}
+}
+
+export function buildCodeMap(cwd: string, maxDepth = 2): CodeMap {
+	const top = listChildren(cwd);
+	const tree = new Map<string, string[]>();
+	const codeCounts: Record<string, number> = {};
+	const keyFiles: { relPath: string; summary: string }[] = [];
+	let hasGithubWorkflows = false;
+
+	// Top-level key files
+	for (const f of top.files) {
+		if (KEY_FILES.has(f) || KEY_FILES.has(`-${f}`)) {
+			const summary = summarizeKeyFile(path.join(cwd, f));
+			keyFiles.push({ relPath: f, summary });
+		}
+	}
+
+	// Walk dirs at depth 1
+	for (const d of top.dirs) {
+		const subPath = path.join(cwd, d);
+		const sub = listChildren(subPath);
+		tree.set(d, sub.dirs);
+
+		// Key files inside top-level dirs (e.g. src/index.ts, src/package.json)
+		for (const f of sub.files) {
+			if (KEY_FILES.has(f)) {
+				keyFiles.push({
+					relPath: `${d}/${f}`,
+					summary: summarizeKeyFile(path.join(subPath, f)),
+				});
+			}
+		}
+
+		// Code count: walk this dir, count by extension
+		let count = 0;
+		try {
+			const stack = [subPath];
+			let depth = 0;
+			while (stack.length > 0 && depth <= maxDepth) {
+				const cur = stack.pop()!;
+				const entries = fs.readdirSync(cur, { withFileTypes: true });
+				for (const e of entries) {
+					if (e.name.startsWith(".")) continue;
+					if (IGNORE_DIRS.has(e.name)) continue;
+					if (e.isDirectory()) {
+						stack.push(path.join(cur, e.name));
+					} else if (e.isFile()) {
+						const ext = e.name.split(".").pop()?.toLowerCase();
+						if (ext && CODE_EXTS.has(ext)) count++;
+					}
+				}
+				depth++;
+			}
+		} catch {
+			// best effort
+		}
+		codeCounts[d] = count;
+
+		// .github/workflows detection
+		if (d === ".github") {
+			const wfDir = path.join(subPath, "workflows");
+			if (fs.existsSync(wfDir)) {
+				try {
+					const wfEntries = fs.readdirSync(wfDir);
+					if (wfEntries.length > 0) hasGithubWorkflows = true;
+				} catch {
+					// ignore
+				}
+			}
+		}
+	}
+
+	return {
+		root: cwd,
+		topLevel: top,
+		tree,
+		keyFiles,
+		codeCounts,
+		hasGithubWorkflows,
+	};
+}
+
+/** Render a compact "## project layout" section for the system prompt. */
+export function buildCodeMapSection(map: CodeMap): string {
+	if (map.topLevel.dirs.length === 0 && map.topLevel.files.length === 0) {
+		return "";
+	}
+
+	const lines: string[] = ["", "## project layout", ""];
+
+	// Top-level tree (1-line ASCII)
+	const allTop = [...map.topLevel.dirs, ...map.topLevel.files].slice(0, 20);
+	lines.push(`\`\`\``);
+	lines.push(`${path.basename(map.root)}/`);
+	for (const name of allTop) {
+		const isDir = map.topLevel.dirs.includes(name);
+		const count = map.codeCounts[name];
+		const suffix = isDir && count ? `  (${count} code file${count === 1 ? "" : "s"})` : "";
+		lines.push(`├── ${name}${isDir ? "/" : ""}${suffix}`);
+	}
+	if (map.topLevel.dirs.length + map.topLevel.files.length > 20) {
+		lines.push(`└── … (${map.topLevel.dirs.length + map.topLevel.files.length - 20} more)`);
+	}
+	lines.push(`\`\`\``);
+	lines.push("");
+
+	// Key files
+	if (map.keyFiles.length > 0) {
+		lines.push("**Key files:**");
+		for (const kf of map.keyFiles.slice(0, 8)) {
+			lines.push(`- \`${kf.relPath}\`${kf.summary ? ` — ${kf.summary}` : ""}`);
+		}
+		if (map.keyFiles.length > 8) {
+			lines.push(`- … and ${map.keyFiles.length - 8} more`);
+		}
+		lines.push("");
+	}
+
+	// CI hint
+	if (map.hasGithubWorkflows) {
+		lines.push("- **CI**: GitHub Actions workflows present");
+	}
+
+	lines.push(
+		"Use `soly_snippet(path, offset, limit)` or `soly_doc_search(query)` to read specific files without loading the whole tree.",
+	);
+
+	return lines.join("\n");
+}

package/hotreload.ts

@@ -0,0 +1,239 @@
+// =============================================================================
+// hotreload.ts — Live file watcher for soly rules
+// =============================================================================
+//
+// Watches all rule source directories (project-soly, global-soly) for
+// changes. When a .md file in any of them is created, modified, or
+// deleted, the extension reloads its rule set and re-renders the status
+// bar — all within the same session, no /reload.
+//
+// Why this matters: editing rules is a tight feedback loop. Without hot
+// reload, you have to wait for the next turn_end (or restart) to see
+// effects. With it, saving a rule file is instantly reflected in the
+// "rules N" counter in the status bar.
+//
+// Two reload strategies in parallel:
+//   1. fs.watch with debounce 100ms — fast, but unreliable on Windows
+//      (recursive watch is buggy, some editor save patterns miss events).
+//   2. Polling fallback every `pollMs` ms — checks mtime of every rule
+//      file. Slower (constant disk I/O) but reliable everywhere.
+// Both feed into the same debounced onChange callback. If fs.watch
+// fires, it preempts the next poll tick (no double reload).
+//
+// Watchers are cleaned up on session_shutdown.
+// =============================================================================
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { SourceSpec } from "./core.ts";
+
+export interface HotReloadOptions {
+	/** Called when any watched file changes (debounced). The `reason` argument
+	 *  carries a human-readable description of what triggered the reload
+	 *  (e.g. `poll:soly/code-style.md`). */
+	onChange: (reason: string) => void;
+	/** Debounce window in ms — coalesce burst writes from editors. */
+	debounceMs?: number;
+	/** Polling interval in ms — fallback when fs.watch is unreliable. */
+	pollMs?: number;
+}
+
+/** Set of FSWatchers + cleanup helper. */
+export interface HotReloadHandle {
+	stop: () => void;
+	/** Manually trigger a refresh (e.g. from turn_end fallback). */
+	tick: (reason: string) => void;
+	/** Install a user-facing notifier that gets coalesced rapid-fire
+	 *  changes into a single message. Optional — the raw onChange still
+	 *  fires per-change for status updates. */
+	setNotifyHandler: (handler: (reason: string) => void) => void;
+}
+
+/** Walk a source dir and return every .md file with its mtime. */
+function snapshotMtimes(dir: string): Map<string, number> {
+	const out = new Map<string, number>();
+	if (!fs.existsSync(dir)) return out;
+	const walk = (d: string) => {
+		let entries: fs.Dirent[];
+		try {
+			entries = fs.readdirSync(d, { withFileTypes: true });
+		} catch {
+			return;
+		}
+		for (const e of entries) {
+			if (e.name.startsWith(".")) continue;
+			if (e.name === "node_modules") continue;
+			const full = path.join(d, e.name);
+			if (e.isDirectory()) {
+				walk(full);
+			} else if (e.isFile() && e.name.endsWith(".md")) {
+				try {
+					const stat = fs.statSync(full);
+					out.set(full, stat.mtimeMs);
+				} catch {
+					// skip unreadable
+				}
+			}
+		}
+	};
+	walk(dir);
+	return out;
+}
+
+export function startHotReload(
+	sources: SourceSpec[],
+	opts: HotReloadOptions,
+): HotReloadHandle {
+	const debounceMs = opts.debounceMs ?? 100;
+	const pollMs = opts.pollMs ?? 2000;
+
+	const watchers: fs.FSWatcher[] = [];
+	let pendingTimer: NodeJS.Timeout | null = null;
+	let pollTimer: NodeJS.Timeout | null = null;
+	let stopped = false;
+
+	// Notification coalescer — editors often save in 2–3 quick bursts
+	// (write to .tmp, rename, touch), which would each fire onChange.
+	// We batch them into a single user-visible notify by accumulating the
+	// most recent reason until the debounce window expires.
+	let pendingNotify: { reasons: string[]; timer: NodeJS.Timeout | null } = {
+		reasons: [],
+		timer: null,
+	};
+	const NOTIFY_COALESCE_MS = 500;
+	let notifyHandler: ((reason: string) => void) | null = null;
+
+	// Wrap user's onChange so that the actual callback still fires per-change
+	// (we can't break that contract — index.ts updates status synchronously),
+	// but a user-facing notify is coalesced. The wrapper just buffers reasons.
+	const wrappedOnChange = (reason: string) => {
+		opts.onChange(reason);
+		if (notifyHandler) {
+			pendingNotify.reasons.push(reason);
+			if (pendingNotify.timer) clearTimeout(pendingNotify.timer);
+			pendingNotify.timer = setTimeout(() => {
+				const reasons = pendingNotify.reasons;
+				pendingNotify = { reasons: [], timer: null };
+				if (reasons.length === 1) {
+					notifyHandler!(reasons[0]!);
+				} else if (reasons.length > 1) {
+					notifyHandler!(
+						`${reasons.length} rapid change(s) (last: ${reasons[reasons.length - 1]})`,
+					);
+				}
+			}, NOTIFY_COALESCE_MS);
+		}
+	};
+
+	const schedule = (reason: string) => {
+		if (stopped) return;
+		if (pendingTimer) clearTimeout(pendingTimer);
+		pendingTimer = setTimeout(() => {
+			pendingTimer = null;
+			if (stopped) return;
+			try {
+				wrappedOnChange(reason);
+				// After reload, update snapshot so polling doesn't re-fire
+				// on the same state until files change again.
+				lastMtimes = new Map();
+				for (const spec of sources) {
+					for (const [p, t] of snapshotMtimes(spec.dir)) {
+						lastMtimes.set(p, t);
+					}
+				}
+			} catch {
+				// Swallow — the consumer's onChange is best-effort
+			}
+		}, debounceMs);
+	};
+
+	// Snapshot of file mtimes for polling. Resets after each reload so we
+	// don't repeatedly fire on the same state.
+	let lastMtimes: Map<string, number> = new Map();
+	for (const spec of sources) {
+		for (const [p, t] of snapshotMtimes(spec.dir)) {
+			lastMtimes.set(p, t);
+		}
+	}
+
+	for (const spec of sources) {
+		if (!fs.existsSync(spec.dir)) continue;
+		try {
+			// recursive: true walks subdirs so nested rule directories work
+			const watcher = fs.watch(
+				spec.dir,
+				{ recursive: true },
+				(_event, filename) => {
+					if (!filename) return;
+					// Ignore non-markdown noise (.swp, .tmp, lock files)
+					const name = String(filename);
+					if (!name.endsWith(".md")) return;
+					schedule(`${spec.sourceLabel}:${name}`);
+				},
+			);
+			watchers.push(watcher);
+		} catch {
+			// Some filesystems don't support recursive watch — polling
+			// fallback below still catches changes.
+		}
+	}
+
+	// Polling fallback — reliable on Windows / network mounts / editors
+	// that don't trigger fs.watch. Coalesces into the same debounce.
+	pollTimer = setInterval(() => {
+		if (stopped) return;
+		let changed: string | null = null;
+		const current = new Map<string, number>();
+		for (const spec of sources) {
+			const snap = snapshotMtimes(spec.dir);
+			for (const [p, t] of snap) {
+				current.set(p, t);
+				const prev = lastMtimes.get(p);
+				if (prev !== t) {
+					changed = `${spec.sourceLabel}:${path.basename(p)}`;
+				}
+			}
+		}
+		// Detect deletions (file present in lastMtimes but missing in current)
+		if (!changed) {
+			for (const p of lastMtimes.keys()) {
+				if (!current.has(p)) {
+					changed = `${path.basename(p)}:deleted`;
+					break;
+				}
+			}
+		}
+		if (changed) schedule(`poll:${changed}`);
+	}, pollMs);
+
+	return {
+		stop: () => {
+			stopped = true;
+			if (pendingTimer) {
+				clearTimeout(pendingTimer);
+				pendingTimer = null;
+			}
+			if (pendingNotify.timer) {
+				clearTimeout(pendingNotify.timer);
+				pendingNotify = { reasons: [], timer: null };
+			}
+			if (pollTimer) {
+				clearInterval(pollTimer);
+				pollTimer = null;
+			}
+			for (const w of watchers) {
+				try {
+					w.close();
+				} catch {
+					// best effort
+				}
+			}
+		},
+		tick: (reason) => schedule(reason),
+		/** Install a user-facing notifier that gets coalesced rapid-fire
+		 *  changes into a single message. Call once from the consumer. */
+		setNotifyHandler: (handler) => {
+			notifyHandler = handler;
+		},
+	};
+}