@vheins/local-memory-mcp 0.19.5 → 0.19.6

package/dist/{chunk-ZSGQQS5F.js → chunk-IT2PAPJ6.js}

@@ -1070,7 +1070,15 @@ var BaseEntity = class {
       status: r.status || "active",
       is_global: r.is_global === 1,
       tags: this.safeJSONParse(r.tags, []),
-      metadata: this.safeJSONParse(r.metadata, {})
+      metadata: (() => {
+        const meta = this.safeJSONParse(r.metadata, {});
+        delete meta.structuredData;
+        return meta;
+      })(),
+      structuredData: (() => {
+        const meta = this.safeJSONParse(r.metadata, {});
+        return meta.structuredData ?? void 0;
+      })()
     };
   }
   rowToTask(row) {
@@ -1162,6 +1170,7 @@ var VALID_COLUMNS = /* @__PURE__ */ new Set([
 ]);
 var MemoryEntity = class extends BaseEntity {
   insert(entry) {
+    const mergedMeta = this.mergeStructuredData(entry.metadata, entry.structuredData);
     this.run(
       `INSERT INTO memories (
 				id, code, repo, owner, type, title, content, importance, folder, language,
@@ -1186,7 +1195,7 @@ var MemoryEntity = class extends BaseEntity {
         entry.status || "active",
         entry.is_global ? 1 : 0,
         entry.tags ? JSON.stringify(entry.tags) : null,
-        entry.metadata ? JSON.stringify(entry.metadata) : null,
+        mergedMeta ? JSON.stringify(mergedMeta) : null,
         entry.agent || "unknown",
         entry.role || "unknown",
         entry.model || "unknown",
@@ -1194,6 +1203,9 @@ var MemoryEntity = class extends BaseEntity {
       ]
     );
   }
+  mergeStructuredData(metadata, structuredData) {
+    return { ...metadata, structuredData: structuredData ?? {} };
+  }
   update(id, updates) {
     const fields = [];
     const values = [];
@@ -1219,6 +1231,12 @@ var MemoryEntity = class extends BaseEntity {
             fields.push("language = ?");
             values.push(scope.language);
           }
+        } else if (k === "structuredData") {
+          const existingRow = this.get("SELECT metadata FROM memories WHERE id = ?", [id]);
+          const existingMeta = existingRow ? this.safeJSONParse(existingRow.metadata, {}) : {};
+          const merged = { ...existingMeta, structuredData: val };
+          fields.push("metadata = ?");
+          values.push(JSON.stringify(merged));
         } else if (k === "tags" || k === "metadata") {
           fields.push(`${k} = ?`);
           values.push(JSON.stringify(val));
@@ -1322,6 +1340,7 @@ var MemoryEntity = class extends BaseEntity {
     return this.transaction(() => {
       let count = 0;
       for (const entry of entries) {
+        const mergedMeta = this.mergeStructuredData(entry.metadata, entry.structuredData);
         this.run(
           `INSERT INTO memories (
 						id, repo, owner, type, title, content, importance, folder, language,
@@ -1345,7 +1364,7 @@ var MemoryEntity = class extends BaseEntity {
             entry.status || "active",
             entry.is_global ? 1 : 0,
             entry.tags ? JSON.stringify(entry.tags) : null,
-            entry.metadata ? JSON.stringify(entry.metadata) : null,
+            mergedMeta ? JSON.stringify(mergedMeta) : null,
             entry.agent || "unknown",
             entry.role || "unknown",
             entry.model || "unknown",
@@ -6457,6 +6476,28 @@ var SingleStandardSchema = z2.object({
   model: z2.string().optional()
 });
 var TaskStatusValues = TaskStatusSchema.options;
+function isPlainObject(v) {
+  return typeof v === "object" && v !== null && !Array.isArray(v) && Object.getPrototypeOf(v) === Object.prototype;
+}
+function isJsonSerializable(val) {
+  try {
+    JSON.stringify(val);
+    return true;
+  } catch {
+    return false;
+  }
+}
+var StructuredDataValue = z2.lazy(
+  () => z2.union([
+    z2.string(),
+    z2.number().refine((v) => Number.isFinite(v), "Number must be finite"),
+    z2.boolean(),
+    z2.null(),
+    z2.array(StructuredDataValue),
+    z2.record(z2.string(), StructuredDataValue).refine(isPlainObject, "Plain object required")
+  ])
+);
+var StructuredDataSchema = z2.unknown().refine(isJsonSerializable, { message: "Value must be JSON-serializable" }).pipe(z2.record(z2.string(), StructuredDataValue));
 
 // src/mcp/tools/schemas/memory.ts
 import { z as z3 } from "zod";
@@ -6538,8 +6579,8 @@ var MemoryAcknowledgeSchema = z3.object({
   message: "Either memory_id or code must be provided"
 });
 var MemoryRecapSchema = z3.object({
-  owner: z3.string().min(1),
-  repo: z3.string().min(1).transform(normalizeRepo),
+  owner: z3.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
+  repo: z3.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   limit: z3.number().min(1).max(50).default(20),
   offset: z3.number().min(0).default(0),
   structured: z3.boolean().default(false)
@@ -6729,8 +6770,8 @@ var TaskUpdateSchema = z4.object({
   message: "At least one field besides repo and id/ids must be provided for update"
 });
 var TaskListSchema = z4.object({
-  owner: z4.string().min(1),
-  repo: z4.string().min(1).transform(normalizeRepo),
+  owner: z4.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
+  repo: z4.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   status: TaskStatusListSchema.default("backlog,pending,in_progress,blocked"),
   phase: z4.string().optional(),
   query: z4.string().optional(),
@@ -6759,7 +6800,9 @@ var TaskDeleteSchema = z4.object({
   structured: z4.boolean().default(false)
 }).refine(
   (data) => data.id !== void 0 || data.ids !== void 0 || data.task_code !== void 0 || data.task_codes !== void 0,
-  { message: "Either 'id', 'ids', 'task_code', or 'task_codes' must be provided for deletion" }
+  {
+    message: "Either 'id' (UUID), 'ids' (array of UUIDs), 'task_code' (string code like PERF-1), or 'task_codes' (array of string codes) must be provided. Note: 'ids' expects UUID format, not task codes \u2014 use 'task_code'/'task_codes' for string identifiers."
+  }
 );
 var TaskGetSchema = z4.object({
   owner: z4.string().min(1),
@@ -6775,8 +6818,8 @@ var TaskGetSchema = z4.object({
 // src/mcp/tools/schemas/handoff.ts
 import { z as z5 } from "zod";
 var HandoffCreateSchema = z5.object({
-  owner: z5.string().min(1).optional().default(""),
-  repo: z5.string().min(1).transform(normalizeRepo),
+  owner: z5.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
+  repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   from_agent: z5.string().min(1),
   to_agent: z5.string().min(1).optional(),
   task_id: z5.string().uuid().optional(),
@@ -6799,8 +6842,8 @@ var HandoffUpdateSchema = z5.object({
   structured: z5.boolean().default(false)
 });
 var HandoffListSchema = z5.object({
-  owner: z5.string().min(1).optional().default(""),
-  repo: z5.string().min(1).transform(normalizeRepo),
+  owner: z5.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
+  repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   status: HandoffStatusSchema.optional(),
   from_agent: z5.string().min(1).optional(),
   to_agent: z5.string().min(1).optional(),
@@ -6809,8 +6852,8 @@ var HandoffListSchema = z5.object({
   structured: z5.boolean().default(false)
 });
 var TaskClaimSchema = z5.object({
-  owner: z5.string().min(1).optional().default(""),
-  repo: z5.string().min(1).transform(normalizeRepo),
+  owner: z5.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
+  repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   task_id: z5.string().uuid().optional(),
   task_code: z5.string().optional(),
   agent: z5.string().min(1),
@@ -6823,8 +6866,8 @@ var TaskClaimSchema = z5.object({
   message: "Provide either task_id or task_code, not both"
 });
 var ClaimListSchema = z5.object({
-  owner: z5.string().min(1).optional().default(""),
-  repo: z5.string().min(1).transform(normalizeRepo),
+  owner: z5.string().optional().default(""),
+  repo: z5.string().transform(normalizeRepo).optional().default(""),
   agent: z5.string().min(1).optional(),
   active_only: z5.boolean().default(true),
   limit: z5.number().min(1).max(100).default(20),
@@ -6832,8 +6875,8 @@ var ClaimListSchema = z5.object({
   structured: z5.boolean().default(false)
 });
 var ClaimReleaseSchema = z5.object({
-  owner: z5.string().min(1).optional().default(""),
-  repo: z5.string().min(1).transform(normalizeRepo),
+  owner: z5.string().min(1, "owner is required \u2014 provide it explicitly or configure MCP workspace roots"),
+  repo: z5.string().min(1, "repo is required \u2014 provide it explicitly or configure MCP workspace roots").transform(normalizeRepo),
   task_id: z5.string().uuid().optional(),
   task_code: z5.string().optional(),
   agent: z5.string().min(1).optional(),
@@ -7070,7 +7113,13 @@ async function handleHandoffCreate(args, storage) {
   });
 }
 async function handleHandoffList(args, storage) {
-  const validated = HandoffListSchema.parse(args);
+  const parsed = HandoffListSchema.safeParse(args);
+  if (!parsed.success) {
+    const missing = parsed.error.issues.filter((i) => i.path.some((p) => p === "owner" || p === "repo")).map((i) => i.message).filter(Boolean);
+    const msg = missing.length > 0 ? `Missing required fields: ${missing.join("; ")}. Pass owner/repo explicitly or configure MCP workspace roots so they can be auto-inferred.` : `Validation error: ${parsed.error.message}`;
+    return { content: [{ type: "text", text: msg }], isError: true };
+  }
+  const validated = parsed.data;
   const { owner, repo, status, from_agent, to_agent, limit, offset, structured } = validated;
   const handoffs = storage.handoffs.listHandoffs({
     owner,

package/dist/dashboard/server.js

@@ -15,7 +15,7 @@ import {
   handleTaskClaim,
   listResources,
   logger
-} from "../chunk-ZSGQQS5F.js";
+} from "../chunk-IT2PAPJ6.js";
 
 // src/dashboard/server.ts
 import express from "express";

package/dist/mcp/server.js

@@ -61,7 +61,7 @@ import {
   parseRepoInput,
   rankCompletionValues,
   toContextSlug
-} from "../chunk-ZSGQQS5F.js";
+} from "../chunk-IT2PAPJ6.js";
 
 // src/mcp/server.ts
 import { serveStdio } from "@modelcontextprotocol/server/stdio";
@@ -74,8 +74,8 @@ import path from "path";
 import { fileURLToPath } from "url";
 var __dirname = path.dirname(fileURLToPath(import.meta.url));
 var pkgVersion = "0.1.0";
-if ("0.19.5") {
-  pkgVersion = "0.19.5";
+if ("0.19.6") {
+  pkgVersion = "0.19.6";
 } else {
   let searchDir = __dirname;
   for (let i = 0; i < 5; i++) {
@@ -1118,7 +1118,13 @@ function extractAcceptedElicitationContent(result) {
 
 // src/mcp/tools/memory.recap.ts
 async function handleMemoryRecap(params, db2) {
-  const validated = MemoryRecapSchema.parse(params);
+  const parsed = MemoryRecapSchema.safeParse(params);
+  if (!parsed.success) {
+    const missing = parsed.error.issues.filter((i) => i.path.some((p) => p === "owner" || p === "repo")).map((i) => i.message).filter(Boolean);
+    const msg = missing.length > 0 ? `Missing required fields: ${missing.join("; ")}. Pass owner/repo explicitly or configure MCP workspace roots so they can be auto-inferred.` : `Validation error: ${parsed.error.message}`;
+    return { content: [{ type: "text", text: msg }], isError: true };
+  }
+  const validated = parsed.data;
   logger.info("[Tool] memory.recap", { repo: validated.repo, limit: validated.limit, offset: validated.offset });
   const stats = db2.memories.getStats(validated.owner, validated.repo);
   const total = db2.memories.getTotalCount(validated.owner, validated.repo, false, ["task_archive"]);
@@ -1241,7 +1247,13 @@ function capitalize3(str) {
   return str.charAt(0).toUpperCase() + str.slice(1);
 }
 async function handleTaskList(args, storage) {
-  const validated = TaskListSchema.parse(args);
+  const parsed = TaskListSchema.safeParse(args);
+  if (!parsed.success) {
+    const missing = parsed.error.issues.filter((i) => i.path.some((p) => p === "owner" || p === "repo")).map((i) => i.message).filter(Boolean);
+    const msg = missing.length > 0 ? `Missing required fields: ${missing.join("; ")}. Pass owner/repo explicitly or configure MCP workspace roots so they can be auto-inferred.` : `Validation error: ${parsed.error.message}`;
+    return { content: [{ type: "text", text: msg }], isError: true };
+  }
+  const validated = parsed.data;
   const { owner, repo, status, phase, query, limit, offset, structured: isStructuredRequest = false } = validated;
   let statuses = [];
   if (status !== "all") {

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@vheins/local-memory-mcp",
-	"version": "0.19.5",
+	"version": "0.19.6",
 	"description": "MCP Local Memory Service for coding copilot agents",
 	"mcpName": "io.github.vheins/local-memory-mcp",
 	"type": "module",