@possumtech/rummy 0.2.1

package/src/agent/KnownStore.js

@@ -0,0 +1,254 @@
+import slugify from "../sql/functions/slugify.js";
+
+export default class KnownStore {
+	#db;
+
+	constructor(db) {
+		this.#db = db;
+	}
+
+	static scheme(path) {
+		const idx = path.indexOf("://");
+		return idx > 0 ? path.slice(0, idx) : null;
+	}
+
+	static normalizePath(path) {
+		if (!path?.includes("://")) return path;
+		return path.replace(/:\/\/(.*)$/, (_, rest) => {
+			try {
+				// Decode first (idempotent), then encode — but preserve slashes
+				const decoded = decodeURIComponent(rest);
+				return `://${decoded.split("/").map(encodeURIComponent).join("/")}`;
+			} catch {
+				return `://${rest.split("/").map(encodeURIComponent).join("/")}`;
+			}
+		});
+	}
+
+	async nextTurn(runId) {
+		const row = await this.#db.next_turn.get({ run_id: runId });
+		return row.turn;
+	}
+
+	async dedup(runId, scheme, target) {
+		const candidate = `${scheme}://${target}`;
+		const existing = await this.#db.get_entry_body.get({
+			run_id: runId,
+			path: KnownStore.normalizePath(candidate),
+		});
+		if (!existing) return candidate;
+		return `${candidate}_${Date.now()}`;
+	}
+
+	async slugPath(runId, scheme, content) {
+		const base = slugify(content || "");
+		const prefix = `${scheme}://`;
+
+		if (!base) return `${prefix}${Date.now()}`;
+
+		const candidate = `${prefix}${base}`;
+		const existing = await this.#db.get_entry_body.get({
+			run_id: runId,
+			path: candidate,
+		});
+		if (!existing) return candidate;
+
+		return `${prefix}${base}_${Date.now()}`;
+	}
+
+	async upsert(
+		runId,
+		turn,
+		path,
+		body,
+		state,
+		{ attributes = null, hash = null, updatedAt = null } = {},
+	) {
+		await this.#db.upsert_known_entry.run({
+			run_id: runId,
+			turn,
+			path: KnownStore.normalizePath(path),
+			body,
+			state,
+			hash,
+			attributes: attributes ? JSON.stringify(attributes) : null,
+			updated_at: updatedAt,
+		});
+	}
+
+	async promote(runId, path, turn) {
+		await this.#db.promote_path.run({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+			turn,
+		});
+	}
+
+	async setFileState(runId, pattern, state) {
+		const result = await this.#db.set_file_state.run({
+			run_id: runId,
+			pattern,
+			state,
+		});
+		if (result.changes === 0) {
+			await this.upsert(runId, 0, pattern, "", state);
+		}
+	}
+
+	async demote(runId, path) {
+		await this.#db.demote_path.run({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+		});
+	}
+
+	async remove(runId, path) {
+		await this.#db.delete_known_entry.run({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+		});
+	}
+
+	async removeFilesByPattern(runId, pattern) {
+		await this.#db.delete_file_entries_by_pattern.run({
+			run_id: runId,
+			pattern,
+		});
+	}
+
+	static #bodyPattern(body) {
+		return body || null;
+	}
+
+	async promoteByPattern(runId, path, body, turn) {
+		await this.#db.promote_by_pattern.run({
+			run_id: runId,
+			path,
+			body: KnownStore.#bodyPattern(body),
+			turn,
+		});
+	}
+
+	async demoteByPattern(runId, path, body) {
+		await this.#db.demote_by_pattern.run({
+			run_id: runId,
+			path,
+			body: KnownStore.#bodyPattern(body),
+		});
+	}
+
+	async getEntriesByPattern(runId, path, body, { limit, offset } = {}) {
+		return this.#db.get_entries_by_pattern.all({
+			run_id: runId,
+			path,
+			body: KnownStore.#bodyPattern(body),
+			limit: limit ?? null,
+			offset: offset ?? null,
+		});
+	}
+
+	async deleteByPattern(runId, path, body) {
+		await this.#db.delete_entries_by_pattern.run({
+			run_id: runId,
+			path,
+			body: KnownStore.#bodyPattern(body),
+		});
+	}
+
+	async updateBodyByPattern(runId, path, body, newBody) {
+		await this.#db.update_body_by_pattern.run({
+			run_id: runId,
+			path,
+			body: KnownStore.#bodyPattern(body),
+			new_body: newBody,
+		});
+	}
+
+	async resolve(runId, path, state, body) {
+		await this.#db.resolve_known_entry.run({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+			state,
+			body,
+		});
+	}
+
+	async getLog(runId) {
+		return this.#db.get_results.all({ run_id: runId });
+	}
+
+	async getFileEntries(runId) {
+		return this.#db.get_file_entries.all({ run_id: runId });
+	}
+
+	async getFileStatesByPattern(runId, pattern) {
+		return this.#db.get_file_states_by_pattern.all({ run_id: runId, pattern });
+	}
+
+	async hasRejections(runId) {
+		const row = await this.#db.has_rejections.get({ run_id: runId });
+		return row.count > 0;
+	}
+
+	async hasAcceptedActions(runId) {
+		const row = await this.#db.has_accepted_actions.get({ run_id: runId });
+		return row.count > 0;
+	}
+
+	async getUnresolved(runId) {
+		return this.#db.get_unresolved.all({ run_id: runId });
+	}
+
+	async countUnknowns(runId) {
+		const row = await this.#db.count_unknowns.get({ run_id: runId });
+		return row.count;
+	}
+
+	async getUnknownValues(runId) {
+		const rows = await this.#db.get_unknown_values.all({ run_id: runId });
+		return new Set(rows.map((r) => r.body));
+	}
+
+	async getBody(runId, path) {
+		const row = await this.#db.get_entry_body.get({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+		});
+		return row?.body ?? null;
+	}
+
+	async setAttributes(runId, path, attrs) {
+		await this.#db.update_entry_attributes.run({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+			attributes: JSON.stringify(attrs),
+		});
+	}
+
+	async getState(runId, path) {
+		return this.#db.get_entry_state.get({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+		});
+	}
+
+	async getAttributes(runId, path) {
+		const row = await this.#db.get_entry_attributes.get({
+			run_id: runId,
+			path: KnownStore.normalizePath(path),
+		});
+		return row?.attributes ? JSON.parse(row.attributes) : null;
+	}
+
+	async getTurnAudit(runId, turn) {
+		return this.#db.get_turn_audit.all({ run_id: runId, turn });
+	}
+
+	static toolFromPath(path) {
+		return KnownStore.scheme(path);
+	}
+
+	static isSystemPath(path) {
+		return path.includes("://");
+	}
+}

package/src/agent/ProjectAgent.js

@@ -0,0 +1,101 @@
+import LlmProvider from "../llm/LlmProvider.js";
+import AgentLoop from "./AgentLoop.js";
+import KnownStore from "./KnownStore.js";
+import TurnExecutor from "./TurnExecutor.js";
+
+export default class ProjectAgent {
+	#db;
+	#hooks;
+	#agentLoop;
+	#knownStore;
+	#llm;
+
+	constructor(db, hooks) {
+		this.#db = db;
+		this.#hooks = hooks;
+		this.#llm = new LlmProvider(db);
+		this.#knownStore = new KnownStore(db);
+
+		const turnExecutor = new TurnExecutor(
+			db,
+			this.#llm,
+			hooks,
+			this.#knownStore,
+		);
+		this.#agentLoop = new AgentLoop(
+			db,
+			this.#llm,
+			hooks,
+			turnExecutor,
+			this.#knownStore,
+		);
+	}
+
+	async init(projectName, projectRoot, configPath) {
+		await this.#hooks.project.init.started.emit({
+			projectName,
+			projectRoot,
+		});
+
+		const projectRow = await this.#db.upsert_project.get({
+			name: projectName,
+			project_root: projectRoot,
+			config_path: configPath || null,
+		});
+		const projectId = projectRow.id;
+
+		await this.#hooks.project.init.completed.emit({
+			projectId,
+			projectRoot,
+			db: this.#db,
+		});
+
+		return { projectId };
+	}
+
+	get entries() {
+		return this.#knownStore;
+	}
+
+	// --- Run operations ---
+
+	async ask(projectId, model, prompt, run = null, options = {}) {
+		return this.#agentLoop.run(
+			"ask",
+			projectId,
+			model,
+			prompt,
+			null,
+			run,
+			options,
+		);
+	}
+
+	async act(projectId, model, prompt, run = null, options = {}) {
+		return this.#agentLoop.run(
+			"act",
+			projectId,
+			model,
+			prompt,
+			null,
+			run,
+			options,
+		);
+	}
+
+	async resolve(run, resolution) {
+		return this.#agentLoop.resolve(run, resolution);
+	}
+
+	async inject(run, message) {
+		return this.#agentLoop.inject(run, message);
+	}
+
+	async getRunHistory(run) {
+		return this.#agentLoop.getRunHistory(run);
+	}
+
+	abortRun(runId) {
+		this.#agentLoop.abort(runId);
+	}
+}

package/src/agent/ResponseHealer.js

@@ -0,0 +1,134 @@
+const MAX_STALLS = Number(process.env.RUMMY_MAX_STALLS) || 3;
+const MAX_REPETITIONS = Number(process.env.RUMMY_MAX_REPETITIONS) || 3;
+
+export default class ResponseHealer {
+	#stallCount = 0;
+	#lastFingerprint = null;
+	#repetitionCount = 0;
+
+	/**
+	 * Heal a missing status tag. Called when the model emits
+	 * neither <summarize/> nor <update/>.
+	 */
+	/**
+	 * Heal a missing status tag. Called when the model emits
+	 * neither <summarize/> nor <update/>.
+	 *
+	 * Plain text with no commands = the model answered. Treat as summary.
+	 * Commands with no status tag = the model is working. Treat as update.
+	 */
+	static healStatus(content, commands) {
+		const trimmed = content.trim();
+
+		// No commands + plain text = answered. Treat as summary.
+		if (commands.length === 0 && trimmed) {
+			console.warn("[RUMMY] Healed: plain text response treated as summary");
+			return { summaryText: trimmed.slice(0, 500), updateText: null };
+		}
+
+		// Only write/unknown commands + no investigation tools = completed action.
+		// The model did the thing without saying <summarize>. Treat as summary.
+		const hasInvestigation = commands.some((c) =>
+			["get", "env", "search", "ask_user"].includes(c.name),
+		);
+		if (!hasInvestigation && commands.length > 0) {
+			const names = commands.map((c) => c.name).join(", ");
+			console.warn(
+				`[RUMMY] Healed: action-only response (${names}) treated as summary`,
+			);
+			return {
+				summaryText: trimmed.slice(0, 500) || "Done.",
+				updateText: null,
+			};
+		}
+
+		console.warn(
+			`[RUMMY] Healed: missing <update>/<summarize>. Tools: ${commands.map((c) => c.name).join(", ") || "none"}`,
+		);
+		return { summaryText: null, updateText: "..." };
+	}
+
+	/**
+	 * Check for repeated tool commands across turns.
+	 * Returns { continue: boolean, reason?: string }
+	 *
+	 * Fingerprints the commands (name + path/query). If the same fingerprint
+	 * repeats for MAX_REPETITIONS consecutive turns, force-complete.
+	 */
+	assessRepetition({ actionCalls, writeCalls }) {
+		const commands = [...(actionCalls || []), ...(writeCalls || [])];
+		if (commands.length === 0) {
+			this.#lastFingerprint = null;
+			this.#repetitionCount = 0;
+			return { continue: true };
+		}
+
+		const fingerprint = commands
+			.map((c) => `${c.name}:${c.path || c.command || c.question || ""}`)
+			.toSorted()
+			.join("|");
+
+		if (fingerprint === this.#lastFingerprint) {
+			this.#repetitionCount++;
+			if (this.#repetitionCount >= MAX_REPETITIONS) {
+				const reason = `Same commands repeated ${this.#repetitionCount} turns`;
+				console.warn(`[RUMMY] Loop detected: ${reason}. Force-completing.`);
+				return { continue: false, reason };
+			}
+			console.warn(
+				`[RUMMY] Repeated commands (${this.#repetitionCount}/${MAX_REPETITIONS}): ${fingerprint.slice(0, 80)}`,
+			);
+		} else {
+			this.#repetitionCount = 1;
+			this.#lastFingerprint = fingerprint;
+		}
+
+		return { continue: true };
+	}
+
+	/**
+	 * Assess whether the run should continue.
+	 *
+	 * Returns { continue: boolean, reason?: string }
+	 *
+	 * Rules:
+	 *   <summarize/> present → done (terminate)
+	 *   <update/> present  → continue (model says it's working)
+	 *   neither present    → warn, increment stall counter, continue
+	 *   stall counter hits MAX_STALLS → force-complete
+	 */
+	assessProgress({ summaryText, updateText, statusHealed }) {
+		if (summaryText) {
+			this.#stallCount = 0;
+			return { continue: false };
+		}
+
+		if (updateText && !statusHealed) {
+			this.#stallCount = 0;
+			return { continue: true };
+		}
+
+		// Healed or neither — model is glitching
+		this.#stallCount++;
+
+		if (this.#stallCount >= MAX_STALLS) {
+			const reason = `${this.#stallCount} turns with no <update/> or <summarize/>`;
+			console.warn(`[RUMMY] Stalled: ${reason}. Force-completing.`);
+			return { continue: false, reason };
+		}
+
+		console.warn(
+			`[RUMMY] No <update/> or <summarize/> (stall ${this.#stallCount}/${MAX_STALLS})`,
+		);
+		return { continue: true };
+	}
+
+	/**
+	 * Reset state for a new run or after resolution resume.
+	 */
+	reset() {
+		this.#stallCount = 0;
+		this.#lastFingerprint = null;
+		this.#repetitionCount = 0;
+	}
+}