stackmem 1.0.17 → 1.0.19

package/dist/cli.js

@@ -353,7 +353,7 @@ async function confirmSupersede(oldId, newContent) {
 }
 async function cmdSave(project, type, content, force = false) {
     if (!MEMORY_TYPES.includes(type)) {
-        fail(`Invalid type "${type}". Must be one of: ${MEMORY_TYPES.join(", ")}`);
+        fail(`Invalid memory type '${type}'. Valid types: decision, constraint, discovery, rejection.`);
     }
     const { data: existingRows, error: existingError } = await supabase
         .from("memories")
@@ -522,13 +522,18 @@ async function cmdSearch(project, query) {
 }
 // --- cm resolve ------------------------------------------------------------
 async function cmdResolve(project, memoryId) {
-    const { error } = await supabase
+    const { data, error } = await supabase
         .from("memories")
         .update({ resolved: true })
         .eq("project", project)
-        .eq("id", memoryId);
+        .eq("id", memoryId)
+        .select("id");
     if (error)
         fail(`Failed to resolve memory: ${error.message}`);
+    if (!data || data.length === 0) {
+        console.log(`No memory found with ID [${memoryId}]`);
+        return;
+    }
     console.log(`Resolved memory [${memoryId}]`);
 }
 // --- cm delete -------------------------------------------------------------
@@ -539,13 +544,18 @@ async function cmdDelete(project, memoryId) {
         .or(`source_id.eq.${memoryId},target_id.eq.${memoryId}`);
     if (linksError)
         fail(`Failed to delete memory links: ${linksError.message}`);
-    const { error } = await supabase
+    const { data, error } = await supabase
         .from("memories")
         .delete()
         .eq("project", project)
-        .eq("id", memoryId);
+        .eq("id", memoryId)
+        .select("id");
     if (error)
         fail(`Failed to delete memory: ${error.message}`);
+    if (!data || data.length === 0) {
+        console.log(`No memory found with ID [${memoryId}]`);
+        return;
+    }
     console.log(`Deleted memory [${memoryId}]`);
 }
 // --- cm inspect ------------------------------------------------------------
@@ -1189,7 +1199,7 @@ async function cmdInit(project, targetPath) {
     const resolvedPath = nodePath.resolve(targetPath);
     const gitDir = nodePath.join(resolvedPath, ".git");
     if (!nodeFs.existsSync(gitDir)) {
-        console.error(`No git repo found at ${targetPath}`);
+        console.error(`No git repo found at ${targetPath}. Run 'git init' first, then run 'cm init' again.`);
         process.exit(1);
     }
     const gitignoreCreated = writeGitignore(resolvedPath);
@@ -1649,7 +1659,14 @@ async function main() {
             let explicitProject;
             let type;
             let rest;
-            if (MEMORY_TYPES.includes(positional[0])) {
+            // Exactly two positional args can only mean <type> <content> with the
+            // project omitted — an explicit project would need a third slot for
+            // content, which wouldn't exist. Without this check, a typo'd type
+            // (failing the MEMORY_TYPES.includes test below) used to fall into
+            // the "explicit project" branch instead, shifting content out of
+            // existence and surfacing a generic usage() dump instead of the
+            // targeted invalid-type error.
+            if (positional.length === 2 || MEMORY_TYPES.includes(positional[0])) {
                 explicitProject = null;
                 [type, ...rest] = positional;
             }
@@ -1657,6 +1674,9 @@ async function main() {
                 explicitProject = positional[0] ?? null;
                 [, type, ...rest] = positional;
             }
+            if (type !== undefined && !MEMORY_TYPES.includes(type)) {
+                fail(`Invalid memory type '${type}'. Valid types: decision, constraint, discovery, rejection.`);
+            }
             if (!type || rest.length === 0)
                 usage();
             const project = requireProject(explicitProject);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stackmem",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "",
   "main": "index.js",
   "type": "module",

package/src/cli.ts

@@ -411,7 +411,7 @@ async function confirmSupersede(oldId: string, newContent: string): Promise<bool
 
 async function cmdSave(project: string, type: string, content: string, force = false) {
   if (!MEMORY_TYPES.includes(type as MemoryType)) {
-    fail(`Invalid type "${type}". Must be one of: ${MEMORY_TYPES.join(", ")}`);
+    fail(`Invalid memory type '${type}'. Valid types: decision, constraint, discovery, rejection.`);
   }
 
 
@@ -617,14 +617,20 @@ async function cmdSearch(project: string, query: string) {
 // --- cm resolve ------------------------------------------------------------
 
 async function cmdResolve(project: string, memoryId: string) {
-  const { error } = await supabase
+  const { data, error } = await supabase
     .from("memories")
     .update({ resolved: true })
     .eq("project", project)
-    .eq("id", memoryId);
+    .eq("id", memoryId)
+    .select("id");
 
   if (error) fail(`Failed to resolve memory: ${error.message}`);
 
+  if (!data || data.length === 0) {
+    console.log(`No memory found with ID [${memoryId}]`);
+    return;
+  }
+
   console.log(`Resolved memory [${memoryId}]`);
 }
 
@@ -638,14 +644,20 @@ async function cmdDelete(project: string, memoryId: string) {
 
   if (linksError) fail(`Failed to delete memory links: ${linksError.message}`);
 
-  const { error } = await supabase
+  const { data, error } = await supabase
     .from("memories")
     .delete()
     .eq("project", project)
-    .eq("id", memoryId);
+    .eq("id", memoryId)
+    .select("id");
 
   if (error) fail(`Failed to delete memory: ${error.message}`);
 
+  if (!data || data.length === 0) {
+    console.log(`No memory found with ID [${memoryId}]`);
+    return;
+  }
+
   console.log(`Deleted memory [${memoryId}]`);
 }
 
@@ -1355,7 +1367,7 @@ async function cmdInit(project: string, targetPath: string) {
   const gitDir = nodePath.join(resolvedPath, ".git");
 
   if (!nodeFs.existsSync(gitDir)) {
-    console.error(`No git repo found at ${targetPath}`);
+    console.error(`No git repo found at ${targetPath}. Run 'git init' first, then run 'cm init' again.`);
     process.exit(1);
   }
 
@@ -1885,7 +1897,14 @@ async function main() {
       let explicitProject: string | null;
       let type: string | undefined;
       let rest: string[];
-      if (MEMORY_TYPES.includes(positional[0] as MemoryType)) {
+      // Exactly two positional args can only mean <type> <content> with the
+      // project omitted — an explicit project would need a third slot for
+      // content, which wouldn't exist. Without this check, a typo'd type
+      // (failing the MEMORY_TYPES.includes test below) used to fall into
+      // the "explicit project" branch instead, shifting content out of
+      // existence and surfacing a generic usage() dump instead of the
+      // targeted invalid-type error.
+      if (positional.length === 2 || MEMORY_TYPES.includes(positional[0] as MemoryType)) {
         explicitProject = null;
         [type, ...rest] = positional;
       } else {
@@ -1893,6 +1912,10 @@ async function main() {
         [, type, ...rest] = positional;
       }
 
+      if (type !== undefined && !MEMORY_TYPES.includes(type as MemoryType)) {
+        fail(`Invalid memory type '${type}'. Valid types: decision, constraint, discovery, rejection.`);
+      }
+
       if (!type || rest.length === 0) usage();
       const project = requireProject(explicitProject);
       await cmdSave(project, type, rest.join(" "), force);