claude-alfred 0.1.0

package/dist/session-start-DUYF6E0V.mjs

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { o as readActive, s as readActiveState, t as SpecDir } from "./types-C3butmI8.mjs";
+import { f as upsertKnowledge, t as countKnowledge } from "./knowledge-CCCixwb8.mjs";
+import { t as detectProject } from "./project-CpgK3fwQ.mjs";
+import { emitAdditionalContext, extractSection, notifyUser } from "./dispatcher-BzOdcjaa.mjs";
+import { openDefaultCached } from "./store-Clcihees.mjs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { join } from "node:path";
+//#region src/hooks/session-start.ts
+async function sessionStart(ev, _signal) {
+	if (!ev.cwd) return;
+	let store;
+	try {
+		store = openDefaultCached();
+	} catch (err) {
+		notifyUser("warning: store open failed: %s", err);
+		return;
+	}
+	try {
+		ingestProjectClaudeMD(store, ev.cwd);
+	} catch (err) {
+		notifyUser("warning: CLAUDE.md ingest failed: %s", err);
+	}
+	try {
+		syncKnowledgeIndex(store, ev.cwd);
+	} catch (err) {
+		notifyUser("warning: knowledge sync failed: %s", err);
+	}
+	if (!existsSync(join(join(ev.cwd, ".alfred", "steering"), "product.md"))) notifyUser("tip: run `/alfred:init` to set up project steering docs, templates, and knowledge index");
+	suggestLedgerReflect(store);
+	injectSpecContext(ev.cwd, ev.source ?? "", store);
+}
+function ingestProjectClaudeMD(store, projectPath) {
+	const claudeMD = join(projectPath, "CLAUDE.md");
+	let content;
+	try {
+		content = readFileSync(claudeMD, "utf-8");
+	} catch {
+		return;
+	}
+	const sections = splitMarkdownSections(content);
+	if (sections.length === 0) return;
+	const proj = detectProject(projectPath);
+	for (const sec of sections) upsertKnowledge(store, {
+		id: 0,
+		filePath: "CLAUDE.md",
+		contentHash: "",
+		title: sec.path,
+		content: sec.content,
+		subType: "project",
+		projectRemote: proj.remote,
+		projectPath: proj.path,
+		projectName: proj.name,
+		branch: proj.branch,
+		createdAt: "",
+		updatedAt: "",
+		hitCount: 0,
+		lastAccessed: "",
+		enabled: true
+	});
+}
+function splitMarkdownSections(md) {
+	const lines = md.split("\n");
+	const sections = [];
+	let currentPath = "";
+	let buf = [];
+	const flush = () => {
+		const content = buf.join("\n").trim();
+		if (currentPath && content) sections.push({
+			path: currentPath,
+			content
+		});
+		buf = [];
+	};
+	for (const line of lines) if (line.startsWith("## ")) {
+		flush();
+		currentPath = line.slice(3).trim();
+	} else if (line.startsWith("# ") && !currentPath) currentPath = line.slice(2).trim();
+	else if (currentPath) buf.push(line);
+	flush();
+	return sections;
+}
+function syncKnowledgeIndex(store, projectPath) {
+	const knowledgeDir = join(projectPath, ".alfred", "knowledge");
+	let files;
+	try {
+		files = readdirSync(knowledgeDir).filter((f) => f.endsWith(".md"));
+	} catch {
+		return;
+	}
+	if (files.length === 0) return;
+	const proj = detectProject(projectPath);
+	let synced = 0;
+	for (const file of files) try {
+		const { frontmatter, body } = parseFrontmatter(readFileSync(join(knowledgeDir, file), "utf-8"));
+		const { changed } = upsertKnowledge(store, {
+			id: 0,
+			filePath: file,
+			contentHash: "",
+			title: frontmatter.id ?? file.replace(".md", ""),
+			content: body,
+			subType: frontmatter.type ?? "general",
+			projectRemote: proj.remote,
+			projectPath: proj.path,
+			projectName: proj.name,
+			branch: proj.branch,
+			createdAt: frontmatter.created_at ?? "",
+			updatedAt: "",
+			hitCount: 0,
+			lastAccessed: "",
+			enabled: true
+		});
+		if (changed) synced++;
+	} catch {
+		continue;
+	}
+	if (synced > 0) notifyUser("synced %d knowledge files to index", synced);
+}
+function parseFrontmatter(content) {
+	const fm = {};
+	if (!content.startsWith("---")) return {
+		frontmatter: fm,
+		body: content
+	};
+	const end = content.indexOf("---", 3);
+	if (end === -1) return {
+		frontmatter: fm,
+		body: content
+	};
+	const fmBlock = content.slice(3, end).trim();
+	for (const line of fmBlock.split("\n")) {
+		const idx = line.indexOf(":");
+		if (idx > 0) {
+			const key = line.slice(0, idx).trim();
+			fm[key] = line.slice(idx + 1).trim();
+		}
+	}
+	return {
+		frontmatter: fm,
+		body: content.slice(end + 3).trim()
+	};
+}
+function suggestLedgerReflect(store) {
+	try {
+		const count = countKnowledge(store, "", "");
+		if (count < 20) return;
+		notifyUser("knowledge health: %d memories. Consider `ledger action=reflect` for a health report.", count);
+	} catch {}
+}
+function injectSpecContext(projectPath, source, store) {
+	let taskSlug;
+	try {
+		taskSlug = readActive(projectPath);
+	} catch {
+		return;
+	}
+	try {
+		if (readActiveState(projectPath).tasks.find((t) => t.slug === taskSlug)?.status === "completed") return;
+	} catch {}
+	const sd = new SpecDir(projectPath, taskSlug);
+	if (!sd.exists()) return;
+	let buf = "";
+	if (source === "compact") {
+		let session = "";
+		try {
+			session = sd.readFile("session.md");
+		} catch {
+			return;
+		}
+		const compactCount = (session.match(/## Compact Marker \[/g) ?? []).length;
+		buf += `\n--- Alfred Protocol: Recovering Task '${taskSlug}' (post-compact #${compactCount}) ---\n`;
+		if (compactCount <= 1) {
+			buf += "Full context recovery (first compact):\n\n";
+			for (const section of sd.allSections()) if (section.content.trim()) buf += `### ${section.file}\n${section.content}\n\n`;
+		} else {
+			buf += "Lightweight recovery (use dossier action=status for full spec):\n\n";
+			buf += `### session.md\n${session}\n\n`;
+		}
+		buf += "--- End Alfred Protocol ---\n";
+		emitAdditionalContext("SessionStart", buf);
+		notifyUser("recovered task '%s' (compact #%d)", taskSlug, compactCount);
+	} else {
+		let session;
+		try {
+			session = sd.readFile("session.md");
+		} catch {
+			return;
+		}
+		if (!session) return;
+		const proj = detectProject(projectPath);
+		const memoryCount = countKnowledge(store, proj.remote, proj.path);
+		buf += `\n--- Alfred Protocol: Active Task '${taskSlug}' ---\n`;
+		if (memoryCount <= 5) {
+			buf += "(Full context — new project)\n\n";
+			for (const section of sd.allSections()) if (section.content.trim()) buf += `### ${section.file}\n${section.content}\n\n`;
+		} else if (memoryCount <= 20) {
+			buf += session + "\n";
+			try {
+				const goal = extractSection(sd.readFile("requirements.md"), "## Goal");
+				if (goal) buf += "\nGoal: " + goal + "\n";
+			} catch {}
+		} else buf += session + "\n";
+		buf += "--- End Alfred Protocol ---\n";
+		emitAdditionalContext("SessionStart", buf);
+		notifyUser("injected context for task '%s' (memories: %d)", taskSlug, memoryCount);
+	}
+}
+//#endregion
+export { sessionStart };

package/dist/store-Clcihees.mjs

@@ -0,0 +1,338 @@
+#!/usr/bin/env node
+import { mkdirSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { homedir } from "node:os";
+import Database from "better-sqlite3";
+const DDL = `
+CREATE TABLE IF NOT EXISTS schema_version (
+    version INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS knowledge_index (
+    id              INTEGER PRIMARY KEY AUTOINCREMENT,
+    file_path       TEXT NOT NULL,
+    content_hash    TEXT NOT NULL,
+    title           TEXT NOT NULL,
+    content         TEXT NOT NULL,
+    sub_type        TEXT NOT NULL DEFAULT 'general',
+    project_remote  TEXT DEFAULT '',
+    project_path    TEXT NOT NULL,
+    project_name    TEXT NOT NULL DEFAULT '',
+    branch          TEXT DEFAULT '',
+    created_at      TEXT NOT NULL,
+    updated_at      TEXT NOT NULL,
+    hit_count       INTEGER DEFAULT 0,
+    last_accessed   TEXT DEFAULT '',
+    enabled         INTEGER DEFAULT 1,
+    UNIQUE(project_remote, project_path, file_path)
+);
+
+CREATE INDEX IF NOT EXISTS idx_ki_project ON knowledge_index(project_remote, project_path);
+CREATE INDEX IF NOT EXISTS idx_ki_sub_type ON knowledge_index(sub_type);
+CREATE INDEX IF NOT EXISTS idx_ki_updated ON knowledge_index(updated_at);
+
+CREATE VIRTUAL TABLE IF NOT EXISTS knowledge_fts USING fts5(
+    title,
+    content,
+    sub_type,
+    content='knowledge_index',
+    content_rowid='id'
+);
+
+CREATE TRIGGER IF NOT EXISTS ki_fts_ai AFTER INSERT ON knowledge_index BEGIN
+    INSERT INTO knowledge_fts(rowid, title, content, sub_type)
+    VALUES (new.id, new.title, new.content, new.sub_type);
+END;
+CREATE TRIGGER IF NOT EXISTS ki_fts_ad AFTER DELETE ON knowledge_index BEGIN
+    INSERT INTO knowledge_fts(knowledge_fts, rowid, title, content, sub_type)
+    VALUES ('delete', old.id, old.title, old.content, old.sub_type);
+END;
+CREATE TRIGGER IF NOT EXISTS ki_fts_au AFTER UPDATE ON knowledge_index BEGIN
+    INSERT INTO knowledge_fts(knowledge_fts, rowid, title, content, sub_type)
+    VALUES ('delete', old.id, old.title, old.content, old.sub_type);
+    INSERT INTO knowledge_fts(rowid, title, content, sub_type)
+    VALUES (new.id, new.title, new.content, new.sub_type);
+END;
+
+CREATE TABLE IF NOT EXISTS tag_aliases (
+    tag   TEXT NOT NULL,
+    alias TEXT NOT NULL,
+    PRIMARY KEY (tag, alias)
+);
+
+CREATE TABLE IF NOT EXISTS embeddings (
+    id         INTEGER PRIMARY KEY AUTOINCREMENT,
+    source     TEXT NOT NULL,
+    source_id  INTEGER NOT NULL,
+    model      TEXT NOT NULL,
+    dims       INTEGER NOT NULL,
+    vector     BLOB NOT NULL,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE (source, source_id)
+);
+
+CREATE TABLE IF NOT EXISTS session_links (
+    claude_session_id TEXT PRIMARY KEY,
+    master_session_id TEXT NOT NULL,
+    project_remote    TEXT DEFAULT '',
+    project_path      TEXT NOT NULL DEFAULT '',
+    task_slug         TEXT NOT NULL DEFAULT '',
+    branch            TEXT DEFAULT '',
+    linked_at         TEXT NOT NULL
+);
+CREATE INDEX IF NOT EXISTS idx_session_links_master ON session_links(master_session_id);
+`;
+const TAG_ALIASES = {
+	auth: [
+		"authentication",
+		"login",
+		"認証",
+		"ログイン"
+	],
+	db: [
+		"database",
+		"sqlite",
+		"データベース"
+	],
+	api: [
+		"endpoint",
+		"rest",
+		"graphql"
+	],
+	test: [
+		"testing",
+		"テスト",
+		"spec"
+	],
+	security: [
+		"セキュリティ",
+		"vulnerability",
+		"脆弱性"
+	],
+	config: [
+		"configuration",
+		"settings",
+		"設定"
+	],
+	deploy: [
+		"deployment",
+		"デプロイ",
+		"release"
+	],
+	perf: [
+		"performance",
+		"パフォーマンス",
+		"optimization",
+		"最適化"
+	],
+	error: [
+		"エラー",
+		"bug",
+		"バグ",
+		"failure"
+	],
+	hook: [
+		"hooks",
+		"フック",
+		"lifecycle"
+	],
+	memory: [
+		"メモリ",
+		"knowledge",
+		"ナレッジ"
+	],
+	spec: [
+		"specification",
+		"仕様",
+		"requirement"
+	],
+	embed: [
+		"embedding",
+		"埋め込み",
+		"vector",
+		"ベクトル"
+	],
+	search: [
+		"検索",
+		"query",
+		"クエリ"
+	],
+	refactor: [
+		"リファクタ",
+		"cleanup",
+		"restructure"
+	],
+	ci: [
+		"ci/cd",
+		"pipeline",
+		"github actions"
+	]
+};
+const LEGACY_TABLES = [
+	"records_fts",
+	"records",
+	"session_links",
+	"tag_aliases",
+	"docs",
+	"docs_fts",
+	"crawl_meta",
+	"doc_feedback",
+	"instincts",
+	"patterns",
+	"pattern_tags",
+	"pattern_files",
+	"patterns_fts",
+	"alerts",
+	"alert_events",
+	"suggestion_outcomes",
+	"failure_solutions",
+	"solution_chains",
+	"learned_episodes",
+	"feedbacks",
+	"coaching_cache",
+	"snr_history",
+	"signal_outcomes",
+	"user_pattern_effectiveness",
+	"user_profile",
+	"user_preferences",
+	"adaptive_baselines",
+	"workflow_sequences",
+	"file_co_changes",
+	"live_session_phases",
+	"live_session_files",
+	"global_tool_sequences",
+	"global_tool_trigrams",
+	"tags",
+	"preferences",
+	"sessions",
+	"events",
+	"compact_events",
+	"decisions",
+	"tool_failures"
+];
+const LEGACY_TRIGGERS = [
+	"records_fts_ai",
+	"records_fts_ad",
+	"records_fts_au",
+	"patterns_fts_ai",
+	"patterns_fts_ad",
+	"patterns_fts_au",
+	"decisions_fts_ai",
+	"decisions_fts_ad",
+	"decisions_fts_au",
+	"docs_fts_ai",
+	"docs_fts_ad",
+	"docs_fts_au",
+	"ki_fts_ai",
+	"ki_fts_ad",
+	"ki_fts_au"
+];
+const LEGACY_INDEXES = [
+	"idx_records_source_type",
+	"idx_records_crawled_at",
+	"idx_records_sub_type",
+	"idx_embeddings_source",
+	"idx_docs_source_type",
+	"idx_docs_crawled_at",
+	"idx_wseq_task",
+	"idx_cochange_a",
+	"idx_live_phases_session",
+	"idx_live_files_session",
+	"idx_gts_from",
+	"idx_gtt_t1t2",
+	"idx_decisions_session",
+	"idx_decisions_timestamp",
+	"idx_instincts_scope",
+	"idx_instincts_domain",
+	"idx_instincts_confidence",
+	"idx_ki_project",
+	"idx_ki_sub_type",
+	"idx_ki_updated"
+];
+const SAFE_IDENTIFIER = /^[a-zA-Z_][a-zA-Z0-9_]*$/;
+function dropSafe(db, kind, name) {
+	if (!SAFE_IDENTIFIER.test(name)) throw new Error(`store: unsafe identifier in DROP ${kind}: "${name}"`);
+	db.exec(`DROP ${kind} IF EXISTS ${name}`);
+}
+function seedTagAliases(db) {
+	const stmt = db.prepare("INSERT OR IGNORE INTO tag_aliases (tag, alias) VALUES (?, ?)");
+	for (const [tag, aliases] of Object.entries(TAG_ALIASES)) for (const alias of aliases) stmt.run(tag, alias);
+}
+function rebuildFromScratch(db) {
+	for (const trigger of LEGACY_TRIGGERS) dropSafe(db, "TRIGGER", trigger);
+	for (const table of LEGACY_TABLES) dropSafe(db, "TABLE", table);
+	for (const table of [
+		"knowledge_fts",
+		"knowledge_index",
+		"embeddings",
+		"session_links",
+		"tag_aliases",
+		"schema_version"
+	]) dropSafe(db, "TABLE", table);
+	for (const idx of LEGACY_INDEXES) dropSafe(db, "INDEX", idx);
+	db.exec(DDL);
+	seedTagAliases(db);
+}
+function setSchemaVersion(db, ver) {
+	db.exec("DELETE FROM schema_version");
+	db.prepare("INSERT INTO schema_version (version) VALUES (?)").run(ver);
+	db.pragma(`user_version = ${ver}`);
+}
+function migrate(db) {
+	let current = 0;
+	try {
+		const row = db.prepare("SELECT version FROM schema_version LIMIT 1").get();
+		if (row) current = row.version;
+	} catch {}
+	if (current === 8) return;
+	db.transaction(() => {
+		rebuildFromScratch(db);
+		setSchemaVersion(db, 8);
+	})();
+}
+//#endregion
+//#region src/store/index.ts
+var Store = class Store {
+	db;
+	dbPath;
+	expectedDims = 0;
+	constructor(db, dbPath) {
+		this.db = db;
+		this.dbPath = dbPath;
+	}
+	static open(dbPath) {
+		mkdirSync(dirname(dbPath), { recursive: true });
+		const db = new Database(dbPath);
+		db.pragma("journal_mode = WAL");
+		db.pragma("foreign_keys = ON");
+		db.pragma("synchronous = NORMAL");
+		db.pragma("cache_size = -8000");
+		db.pragma("mmap_size = 268435456");
+		db.pragma("temp_store = MEMORY");
+		if (db.pragma("user_version", { simple: true }) !== 8) migrate(db);
+		return new Store(db, dbPath);
+	}
+	static openDefault() {
+		return Store.open(defaultDBPath());
+	}
+	close() {
+		this.db.close();
+	}
+	schemaVersionCurrent() {
+		try {
+			return this.db.prepare("SELECT version FROM schema_version LIMIT 1").get()?.version ?? 0;
+		} catch {
+			return 0;
+		}
+	}
+};
+let cachedStore;
+function openDefaultCached() {
+	if (!cachedStore) cachedStore = Store.openDefault();
+	return cachedStore;
+}
+function defaultDBPath() {
+	return join(homedir(), ".claude-alfred", "alfred.db");
+}
+//#endregion
+export { Store, openDefaultCached };