feat(memory): # quick-add memory from the input line

Typing `# always run the linter` (or `#feedback: …` to pick the bucket)
saves a memory without spending an agent turn — bypasses the busy queue
since it's a local write. Mirrors Claude Code's # shortcut.

Author: halfaipg

src/memory/quick-add.test.ts

@@ -0,0 +1,45 @@
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { quickAddMemory } from "./quick-add.js";
+import { MemoryStore } from "./store.js";
+
+describe("quickAddMemory", () => {
+	let cwd: string;
+	let store: MemoryStore;
+
+	beforeEach(() => {
+		cwd = mkdtempSync(join(tmpdir(), "quickmem-"));
+		store = new MemoryStore({ cwd });
+	});
+	afterEach(() => {
+		rmSync(cwd, { recursive: true, force: true });
+	});
+
+	it("saves a user memory from a bare # line", () => {
+		const rec = quickAddMemory(store, "# always run the linter before committing");
+		expect(rec.type).toBe("user");
+		expect(rec.body).toBe("always run the linter before committing");
+		expect(store.list()).toHaveLength(1);
+	});
+
+	it("honors a #<type>: prefix", () => {
+		const rec = quickAddMemory(store, "#feedback: prefer small focused commits");
+		expect(rec.type).toBe("feedback");
+		expect(rec.body).toBe("prefer small focused commits");
+	});
+
+	it("derives a kebab slug filename and a clipped name", () => {
+		const long = `# ${"word ".repeat(30)}`;
+		const rec = quickAddMemory(store, long);
+		expect(rec.filename).toMatch(/\.md$/);
+		expect(rec.name.endsWith("…")).toBe(true);
+	});
+
+	it("two quick-adds don't collide on filename", () => {
+		quickAddMemory(store, "# note one");
+		quickAddMemory(store, "# note two");
+		expect(store.list()).toHaveLength(2);
+	});
+});

src/memory/quick-add.ts

@@ -0,0 +1,31 @@
+import type { MemoryStore } from "./store.js";
+import type { MemoryRecord, MemoryType } from "./types.js";
+
+/**
+ * Quick-add a memory from a `#`-prefixed input line. The user types
+ * `# always run the linter before committing` and it lands as a memory
+ * file without spending an agent turn. An optional `#<type>:` prefix
+ * picks the bucket (`#feedback: …`, `#project: …`); default is `user`.
+ */
+
+const TYPE_PREFIX = /^#\s*(user|feedback|project|reference)\s*:\s*/i;
+
+export function quickAddMemory(store: MemoryStore, raw: string): MemoryRecord {
+	const body = raw.replace(/^#/, "").trim();
+	let type: MemoryType = "user";
+	let text = body;
+	const typed = raw.match(TYPE_PREFIX);
+	if (typed) {
+		type = typed[1].toLowerCase() as MemoryType;
+		text = raw.slice(typed[0].length).trim();
+	}
+	const name = text.length > 60 ? `${text.slice(0, 57)}…` : text;
+	const slug =
+		text
+			.toLowerCase()
+			.replace(/[^a-z0-9]+/g, "-")
+			.replace(/^-+|-+$/g, "")
+			.slice(0, 40) || "note";
+	const filename = `${slug}-${Date.now().toString(36)}.md`;
+	return store.save({ filename, name, description: name, type, body: text });
+}