@phi-code-admin/phi-code 0.63.1 → 0.63.3

package/extensions/phi/memory.ts

@@ -4,10 +4,10 @@
  * Now powered by sigma-memory package which provides:
  * - NotesManager: Markdown files management
  * - OntologyManager: Knowledge graph with entities and relations  
- * - QMDManager: Vector search (if QMD is available)
+ * - VectorStore: Embedded vector search (sql.js + local embeddings)
  *
  * Features:
- * - memory_search: Unified search across notes, ontology, and QMD
+ * - memory_search: Unified search across notes, ontology, and vector store
  * - memory_write: Write content to memory files
  * - memory_read: Read specific memory files or list available ones
  * - memory_status: Get status of all memory subsystems
@@ -26,16 +26,12 @@ import { readFileSync } from "node:fs";
 import { SigmaMemory } from "sigma-memory";
 
 export default function memoryExtension(pi: ExtensionAPI) {
-	// Initialize sigma-memory
-	const sigmaMemory = new SigmaMemory({
-		// Default configuration, can be overridden
-		qmdEnabled: true,
-		qmdCommand: 'qmd'
-	});
+	// Initialize sigma-memory with embedded vector store
+	const sigmaMemory = new SigmaMemory();
 
-	// Initialize memory directories
-	sigmaMemory.init().catch(error => {
-		console.warn("Failed to initialize sigma-memory:", error);
+	// Initialize memory + vector store (lazy model download on first search)
+	sigmaMemory.init().catch(() => {
+		// Non-critical — memory works without vectors
 	});
 
 	/**
@@ -44,12 +40,15 @@ export default function memoryExtension(pi: ExtensionAPI) {
 	pi.registerTool({
 		name: "memory_search",
 		label: "Memory Search",
-		description: "Search for content in memory using unified search (notes + ontology + QMD vector search)",
+		description: "Search for content in memory using unified search (notes + ontology + vector search)",
 		promptSnippet: "Search project memory (notes, ontology, vector search). ALWAYS call before answering questions about prior work, decisions, or project context.",
 		promptGuidelines: [
 			"Before answering questions about prior work, architecture, decisions, or project context: call memory_search first.",
 			"When starting work on a topic, search memory for existing notes and learnings.",
 			"After completing important work or learning something new, use memory_write to save it.",
+			"When a command fails or produces an unexpected error, document the error and fix in memory_write (self-improvement).",
+			"When the user corrects you, save the correction in memory_write so you never repeat the mistake.",
+			"After a significant debugging session, write a summary of root cause and solution to memory.",
 		],
 		parameters: Type.Object({
 			query: Type.String({ description: "Search query to find in memory" }),
@@ -96,7 +95,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 								resultText += `Relation: ${data.type} (${data.from} → ${data.to})\n`;
 								resultText += `Properties: ${JSON.stringify(data.properties)}\n\n`;
 							}
-						} else if (result.source === 'qmd') {
+						} else if (result.source === 'vectors') {
 							const data = result.data;
 							resultText += `File: ${data.file} (line ${data.line})\n`;
 							resultText += `> ${data.content}\n\n`;
@@ -136,14 +135,18 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			const { content, file } = params as { content: string; file?: string };
 
 			try {
-				// Use notes manager to write
+				// Write to notes
 				sigmaMemory.notes.write(content, file);
-
 				const filename = file || new Date().toISOString().split('T')[0] + '.md';
+
+				// Auto-index in vector store (non-blocking)
+				sigmaMemory.vectors.addDocument(filename, content).catch(() => {
+					// Vector indexing failed silently — notes still saved
+				});
 				
 				return {
-					content: [{ type: "text", text: `Content written to ${filename}` }],
-					details: { filename, contentLength: content.length }
+					content: [{ type: "text", text: `Content written to ${filename} (indexed for vector search)` }],
+					details: { filename, contentLength: content.length, vectorIndexed: true }
 				};
 
 			} catch (error) {
@@ -208,13 +211,141 @@ export default function memoryExtension(pi: ExtensionAPI) {
 		},
 	});
 
+	/**
+	 * Ontology tool - Add entities and relations to the knowledge graph
+	 */
+	pi.registerTool({
+		name: "ontology_add",
+		label: "Ontology Add",
+		description: "Add an entity or relation to the project knowledge graph. Entities represent things (projects, files, services, people). Relations connect them.",
+		promptGuidelines: [
+			"When discovering project architecture (services, databases, APIs), add entities and relations to the ontology.",
+			"When learning about how components connect, add relations (e.g. 'api-server' → 'uses' → 'postgres-db').",
+		],
+		parameters: Type.Object({
+			type: Type.Union([Type.Literal("entity"), Type.Literal("relation")], { description: "What to add: 'entity' or 'relation'" }),
+			// Entity fields
+			entityType: Type.Optional(Type.String({ description: "Entity type (e.g. Project, Service, Database, File, Person, Tool)" })),
+			name: Type.Optional(Type.String({ description: "Entity name (e.g. 'my-api', 'postgres-db')" })),
+			properties: Type.Optional(Type.Record(Type.String(), Type.String(), { description: "Key-value properties (e.g. {language: 'TypeScript', port: '3000'})" })),
+			// Relation fields
+			from: Type.Optional(Type.String({ description: "Source entity ID" })),
+			to: Type.Optional(Type.String({ description: "Target entity ID" })),
+			relationType: Type.Optional(Type.String({ description: "Relation type (e.g. 'uses', 'depends-on', 'deployed-on', 'created-by')" })),
+		}),
+
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params as any;
+			try {
+				if (p.type === "entity") {
+					if (!p.entityType || !p.name) {
+						return { content: [{ type: "text", text: "Entity requires 'entityType' and 'name'" }], isError: true };
+					}
+					const id = sigmaMemory.ontology.addEntity({
+						type: p.entityType,
+						name: p.name,
+						properties: p.properties || {},
+					});
+					return {
+						content: [{ type: "text", text: `Entity added: **${p.name}** (${p.entityType}) — ID: \`${id}\`` }],
+						details: { id, type: p.entityType, name: p.name },
+					};
+				} else if (p.type === "relation") {
+					if (!p.from || !p.to || !p.relationType) {
+						return { content: [{ type: "text", text: "Relation requires 'from', 'to', and 'relationType'" }], isError: true };
+					}
+					const id = sigmaMemory.ontology.addRelation({
+						from: p.from,
+						to: p.to,
+						type: p.relationType,
+						properties: p.properties || {},
+					});
+					return {
+						content: [{ type: "text", text: `Relation added: \`${p.from}\` → **${p.relationType}** → \`${p.to}\` — ID: \`${id}\`` }],
+						details: { id, from: p.from, to: p.to, type: p.relationType },
+					};
+				}
+				return { content: [{ type: "text", text: "Type must be 'entity' or 'relation'" }], isError: true };
+			} catch (error) {
+				return { content: [{ type: "text", text: `Ontology error: ${error}` }], isError: true };
+			}
+		},
+	});
+
+	/**
+	 * Ontology query tool - Query the knowledge graph
+	 */
+	pi.registerTool({
+		name: "ontology_query",
+		label: "Ontology Query",
+		description: "Query the project knowledge graph. Find entities by type/name, get relations, find paths between entities, or get stats.",
+		parameters: Type.Object({
+			action: Type.Union([
+				Type.Literal("find"),
+				Type.Literal("relations"),
+				Type.Literal("path"),
+				Type.Literal("stats"),
+				Type.Literal("graph"),
+			], { description: "Query action: find (entities), relations (of entity), path (between entities), stats, graph (full export)" }),
+			entityType: Type.Optional(Type.String({ description: "Filter by entity type (for 'find' action)" })),
+			name: Type.Optional(Type.String({ description: "Filter by name (partial match, for 'find' action)" })),
+			entityId: Type.Optional(Type.String({ description: "Entity ID (for 'relations' action)" })),
+			fromId: Type.Optional(Type.String({ description: "Source entity ID (for 'path' action)" })),
+			toId: Type.Optional(Type.String({ description: "Target entity ID (for 'path' action)" })),
+		}),
+
+		async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+			const p = params as any;
+			try {
+				switch (p.action) {
+					case "find": {
+						const results = sigmaMemory.ontology.findEntity({ type: p.entityType, name: p.name });
+						if (results.length === 0) return { content: [{ type: "text", text: "No entities found." }] };
+						const text = results.map(e => `- **${e.name}** (${e.type}) ID:\`${e.id}\` ${JSON.stringify(e.properties)}`).join("\n");
+						return { content: [{ type: "text", text: `Found ${results.length} entities:\n${text}` }] };
+					}
+					case "relations": {
+						if (!p.entityId) return { content: [{ type: "text", text: "'entityId' required" }], isError: true };
+						const rels = sigmaMemory.ontology.findRelations(p.entityId);
+						if (rels.length === 0) return { content: [{ type: "text", text: "No relations found." }] };
+						const text = rels.map(r => `- \`${r.from}\` → **${r.type}** → \`${r.to}\``).join("\n");
+						return { content: [{ type: "text", text: `Found ${rels.length} relations:\n${text}` }] };
+					}
+					case "path": {
+						if (!p.fromId || !p.toId) return { content: [{ type: "text", text: "'fromId' and 'toId' required" }], isError: true };
+						const path = sigmaMemory.ontology.queryPath(p.fromId, p.toId);
+						if (!path) return { content: [{ type: "text", text: "No path found between these entities." }] };
+						const text = path.map(s => `${s.entity.name}${s.relation ? ` → [${s.relation.type}]` : ""}`).join(" → ");
+						return { content: [{ type: "text", text: `Path: ${text}` }] };
+					}
+					case "stats": {
+						const stats = sigmaMemory.ontology.stats();
+						const graph = sigmaMemory.ontology.getGraph();
+						let text = `**Ontology Stats:**\n- Entities: ${graph.entities.length}\n- Relations: ${graph.relations.length}\n`;
+						text += `\nBy type:\n`;
+						for (const [type, count] of Object.entries(stats.entitiesByType)) text += `  - ${type}: ${count}\n`;
+						return { content: [{ type: "text", text }] };
+					}
+					case "graph": {
+						const graph = sigmaMemory.ontology.export();
+						return { content: [{ type: "text", text: JSON.stringify(graph, null, 2) }] };
+					}
+					default:
+						return { content: [{ type: "text", text: "Action must be: find, relations, path, stats, graph" }], isError: true };
+				}
+			} catch (error) {
+				return { content: [{ type: "text", text: `Ontology query error: ${error}` }], isError: true };
+			}
+		},
+	});
+
 	/**
 	 * Memory status tool - Get status of all memory subsystems
 	 */
 	pi.registerTool({
 		name: "memory_status",
 		label: "Memory Status",
-		description: "Get status of all memory subsystems (notes, ontology, QMD)",
+		description: "Get status of all memory subsystems (notes, ontology, vector search)",
 		parameters: Type.Object({}),
 
 		async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
@@ -236,14 +367,11 @@ export default function memoryExtension(pi: ExtensionAPI) {
 				statusText += `- Entities by type: ${JSON.stringify(status.ontology.entitiesByType)}\n`;
 				statusText += `- Relations by type: ${JSON.stringify(status.ontology.relationsByType)}\n\n`;
 				
-				// QMD status
-				statusText += `## QMD Vector Search\n`;
-				statusText += `- Available: ${status.qmd.available ? 'Yes' : 'No'}\n`;
-				if (status.qmd.available && status.qmd.status) {
-					statusText += `- Files indexed: ${status.qmd.status.files}\n`;
-					statusText += `- Chunks: ${status.qmd.status.chunks}\n`;
-					statusText += `- Last update: ${status.qmd.status.lastUpdate || 'Never'}\n`;
-				}
+				// Vector store status
+				statusText += `## Vector Search (embedded)\n`;
+				statusText += `- Documents: ${status.vectors.documentCount}\n`;
+				statusText += `- Chunks: ${status.vectors.chunkCount}\n`;
+				statusText += `- Last update: ${status.vectors.lastUpdate || 'Never'}\n`;
 
 				return {
 					content: [{ type: "text", text: statusText }],
@@ -292,7 +420,7 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			const parts: string[] = [];
 			if (status.notes.count > 0) parts.push(`${status.notes.count} notes`);
 			if (status.ontology.entities > 0) parts.push(`${status.ontology.entities} entities`);
-			if (status.qmd.available) parts.push("QMD active");
+			if (status.vectors.chunkCount > 0) parts.push(`${status.vectors.chunkCount} vectors`);
 			if (parts.length > 0) {
 				ctx.ui.notify(`🧠 Memory: ${parts.join(", ")}`, "info");
 			}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@phi-code-admin/phi-code",
-	"version": "0.63.1",
+	"version": "0.63.3",
 	"description": "Coding agent CLI with read, bash, edit, write tools and session management",
 	"type": "module",
 	"piConfig": {
@@ -61,7 +61,7 @@
 		"phi-code-tui": "^0.56.3",
 		"proper-lockfile": "^4.1.2",
 		"sigma-agents": "^0.1.6",
-		"sigma-memory": "^0.1.2",
+		"sigma-memory": "0.2.0",
 		"sigma-skills": "^0.1.2",
 		"strip-ansi": "^7.1.0",
 		"undici": "^7.19.1",

package/scripts/postinstall.cjs

@@ -58,7 +58,18 @@ for (const pkg of sigmaPackages) {
   createLink(srcPkg, destLink, pkg);
 }
 
-// 3. Ensure settings.json has quietStartup: true
+// 3. Ensure memory directories exist (vector store DB created on first use)
+const memoryDir = join(homedir(), ".phi", "memory");
+const memoryNotesDir = join(memoryDir, "notes");
+const memoryOntologyDir = join(memoryDir, "ontology");
+for (const dir of [memoryDir, memoryNotesDir, memoryOntologyDir]) {
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+    console.log(`  Φ Created ${dir}`);
+  }
+}
+
+// 4. Ensure settings.json has quietStartup: true
 const settingsPath = join(agentDir, "settings.json");
 try {
   let settings = {};