memorix 1.4.3 → 1.4.4

package/src/cli/commands/memory.ts

@@ -5,6 +5,7 @@ import { getAllObservations, getObservation, getProjectObservations, resolveObse
 import { buildGraphContextPacket, formatGraphContextPrompt } from '../../memory/graph-context.js';
 import { canManageObservation, filterReadableObservations, resolveObservationVisibility } from '../../memory/visibility.js';
 import {
+  asStringArg,
   coerceObservationStatus,
   coerceObservationType,
   coerceRetrievalQuality,
@@ -12,6 +13,7 @@ import {
   emitResult,
   getCliReadContext,
   getCliProjectContext,
+  lastStringArg,
   parseCsvList,
   parsePositiveInt,
   resolveCliWriteScope,
@@ -66,7 +68,7 @@ export default defineCommand({
     const action = (args._ as string[])?.[0] || '';
     const positional = ((args._ as string[]) ?? []).slice(1);
     const longTermAction = action === 'long-term'
-      ? (positional[0] || (args.action as string | undefined) || 'list').trim().toLowerCase()
+      ? (positional[0] || asStringArg(args.action) || 'list').trim().toLowerCase()
       : undefined;
     const asJson = !!args.json;
 
@@ -107,7 +109,7 @@ export default defineCommand({
             query,
             limit: parsePositiveInt(args.graphLimit as string | undefined, 5),
           });
-          const format = (args.format as string | undefined)?.trim().toLowerCase();
+          const format = asStringArg(args.format)?.toLowerCase();
           const formatted = format === 'prompt'
             ? formatGraphContextPrompt(packet)
             : [
@@ -146,10 +148,10 @@ export default defineCommand({
             emitError('text is required for "memorix memory store"', asJson);
             return;
           }
-          const title = (args.title as string | undefined)?.trim() || narrative.slice(0, 80);
+          const title = asStringArg(args.title) || narrative.slice(0, 80);
           const type = coerceObservationType(args.type as string | undefined);
           const topicKey =
-            (args.topicKey as string | undefined)?.trim() ||
+            asStringArg(args.topicKey) ||
             suggestTopicKey(type, title) ||
             undefined;
           const writeScope = resolveCliWriteScope(
@@ -157,7 +159,7 @@ export default defineCommand({
             args.visibility as string | undefined,
           );
           const result = await storeObservation({
-            entityName: (args.entity as string | undefined)?.trim() || 'general',
+            entityName: asStringArg(args.entity) || 'general',
             type,
             title,
             narrative,
@@ -179,7 +181,7 @@ export default defineCommand({
 
         case 'suggest-topic-key': {
           const type = coerceObservationType(args.type as string | undefined);
-          const title = (args.title as string | undefined)?.trim();
+          const title = asStringArg(args.title);
           if (!title) {
             emitError('title is required for "memorix memory suggest-topic-key"', asJson);
             return;
@@ -274,7 +276,7 @@ export default defineCommand({
         }
 
         case 'deduplicate': {
-          const query = (args.query as string | undefined)?.trim();
+          const query = asStringArg(args.query);
           const dryRun = !!args.dryRun || !!args['dry-run'];
           const { isLLMEnabled } = await import('../../llm/provider.js');
           if (!isLLMEnabled()) {
@@ -479,8 +481,8 @@ export default defineCommand({
           };
 
           const memoryId = (): string => {
-            const id = (args.id as string | undefined)?.trim()
-              || (args.fromObservation as string | undefined)?.trim()
+            const id = asStringArg(args.id)
+              || asStringArg(args.fromObservation)
               || longTermPositional[0]?.trim();
             if (!id) throw new Error('long-term memory id is required.');
             return id;
@@ -535,11 +537,11 @@ export default defineCommand({
                 projectId: project.id,
                 scope: scope(),
                 kind: kind(),
-                title: (args.title as string | undefined)?.trim() || content.slice(0, 100),
+                title: asStringArg(args.title) || content.slice(0, 100),
                 content,
                 facts: parseCsvList(args.facts as string | undefined),
                 tags: parseCsvList(args.tags as string | undefined),
-                applicability: (args.applicability as string | undefined)?.trim(),
+                applicability: asStringArg(args.applicability),
                 portability: portability(),
                 reader: longTermReader,
               });
@@ -552,8 +554,8 @@ export default defineCommand({
             }
 
             case 'promote': {
-              const rawId = (args.fromObservation as string | undefined)?.trim()
-                || (args.id as string | undefined)?.trim()
+              const rawId = asStringArg(args.fromObservation)
+                || asStringArg(args.id)
                 || longTermPositional[0]?.trim();
               const observationId = Number.parseInt(rawId || '', 10);
               if (!Number.isFinite(observationId)) {
@@ -571,7 +573,7 @@ export default defineCommand({
                 scope: scope(),
                 kind: kind(),
                 tags: parseCsvList(args.tags as string | undefined),
-                applicability: (args.applicability as string | undefined)?.trim(),
+                applicability: asStringArg(args.applicability),
                 reader: longTermReader,
               });
               emitResult(
@@ -604,8 +606,8 @@ export default defineCommand({
             }
 
             case 'supersede': {
-              const supersededBy = (args.supersededBy as string | undefined)?.trim()
-                || (args['superseded-by'] as string | undefined)?.trim();
+              const supersededBy = asStringArg(args.supersededBy)
+                || asStringArg(args['superseded-by']);
               if (!supersededBy) {
                 emitError('supersededBy is required for "memorix memory long-term supersede"', asJson);
                 return;
@@ -642,31 +644,39 @@ export default defineCommand({
   },
 });
 
-function getStringArg(named: string | undefined, positional: string[]): string | undefined {
-  const value = named?.trim() || positional.join(' ').trim();
+/**
+ * Read a free-text citty named argument with positional fallback.
+ *
+ * Named values may be arrays: citty accumulates repeated flags and Windows
+ * shells can split one long quoted argument into argv fragments that
+ * re-introduce the flag mid-value (issue #194). Joining array fragments
+ * preserves the original text instead of throwing on `.trim()`.
+ */
+function getStringArg(named: unknown, positional: string[]): string | undefined {
+  const value = asStringArg(named) || positional.join(' ').trim();
   return value || undefined;
 }
 
 function getIdArg(args: Record<string, unknown>, positional: string[]): string {
   return (
-    (args.ids as string | undefined) ||
-    (args.id as string | undefined) ||
+    lastStringArg(args.ids) ||
+    lastStringArg(args.id) ||
     positional.join(',')
   );
 }
 
-function parseObservationId(value: string): number {
-  const normalized = value.trim();
+function parseObservationId(value: unknown): number {
+  const normalized = (asStringArg(value) ?? '').trim();
   if (!/^[1-9]\d*$/.test(normalized)) {
-    throw new Error(`Invalid observation ID: ${value}`);
+    throw new Error(`Invalid observation ID: ${String(value ?? '')}`);
   }
   const id = Number(normalized);
-  if (!Number.isSafeInteger(id)) throw new Error(`Invalid observation ID: ${value}`);
+  if (!Number.isSafeInteger(id)) throw new Error(`Invalid observation ID: ${String(value ?? '')}`);
   return id;
 }
 
-function parseObservationIds(value: string): number[] {
-  const values = parseCsvList(value);
+function parseObservationIds(value: unknown): number[] {
+  const values = parseCsvList(typeof value === 'string' || Array.isArray(value) ? value : undefined);
   if (values.length === 0) return [];
   return values.map(parseObservationId);
 }
@@ -695,26 +705,26 @@ function printMemoryUsage(): void {
   console.log('  memorix memory long-term supersede --id <old-id> --superseded-by <qualified-id> --reason "replaced"');
 }
 
-function longTermKind(value: string | undefined): 'episodic' | 'semantic' | 'procedural' {
-  const normalized = (value ?? 'semantic').trim().toLowerCase();
+function longTermKind(value: unknown): 'episodic' | 'semantic' | 'procedural' {
+  const normalized = (asStringArg(value) ?? 'semantic').toLowerCase();
   if (normalized === 'episodic' || normalized === 'semantic' || normalized === 'procedural') return normalized;
   throw new Error('long-term kind must be episodic, semantic, or procedural.');
 }
 
-function longTermScope(value: string | undefined): 'project' | 'user' | 'team' {
-  const normalized = (value ?? 'project').trim().toLowerCase();
+function longTermScope(value: unknown): 'project' | 'user' | 'team' {
+  const normalized = (asStringArg(value) ?? 'project').toLowerCase();
   if (normalized === 'project' || normalized === 'user' || normalized === 'team') return normalized;
   throw new Error('long-term scope must be project, user, or team.');
 }
 
-function longTermPortability(value: string | undefined): 'project-bound' | 'portable' {
-  const normalized = (value ?? 'project-bound').trim().toLowerCase();
+function longTermPortability(value: unknown): 'project-bound' | 'portable' {
+  const normalized = (asStringArg(value) ?? 'project-bound').toLowerCase();
   if (normalized === 'project-bound' || normalized === 'portable') return normalized;
   throw new Error('long-term portability must be project-bound or portable.');
 }
 
-function requiredLongTermReason(value: string | undefined): string {
-  const reason = value?.trim();
+function requiredLongTermReason(value: unknown): string {
+  const reason = asStringArg(value);
   if (!reason) throw new Error('reason is required for this long-term memory transition.');
   return reason;
 }

package/src/cli/commands/message.ts

@@ -1,27 +1,27 @@
-import { defineCommand } from 'citty';
+import { defineCommand } from 'citty';
 import { emitError, emitResult, getCliProjectContext, resolveCliActorId, shortId } from './operator-shared.js';
-
-export default defineCommand({
-  meta: {
-    name: 'message',
-    description: 'Send, broadcast, and read team messages from the CLI',
-  },
-  args: {
-    from: { type: 'string', description: 'Sender agent ID' },
-    to: { type: 'string', description: 'Recipient agent ID' },
-    type: { type: 'string', description: 'Message type (request, response, info, handoff, etc.)' },
-    content: { type: 'string', description: 'Message content' },
-    agentId: { type: 'string', description: 'Agent ID for inbox reads' },
-    markRead: { type: 'boolean', description: 'Mark inbox messages as read after listing them' },
-    toRole: { type: 'string', description: 'Optional role target for the message' },
-    handoffStatus: { type: 'string', description: 'Optional handoff status when type=handoff' },
-    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
-  },
-  run: async ({ args }) => {
-    const action = (args._ as string[])?.[0] || '';
-    const asJson = !!args.json;
-
-    try {
+
+export default defineCommand({
+  meta: {
+    name: 'message',
+    description: 'Send, broadcast, and read team messages from the CLI',
+  },
+  args: {
+    from: { type: 'string', description: 'Sender agent ID' },
+    to: { type: 'string', description: 'Recipient agent ID' },
+    type: { type: 'string', description: 'Message type (request, response, info, handoff, etc.)' },
+    content: { type: 'string', description: 'Message content' },
+    agentId: { type: 'string', description: 'Agent ID for inbox reads' },
+    markRead: { type: 'boolean', description: 'Mark inbox messages as read after listing them' },
+    toRole: { type: 'string', description: 'Optional role target for the message' },
+    handoffStatus: { type: 'string', description: 'Optional handoff status when type=handoff' },
+    json: { type: 'boolean', description: 'Emit machine-readable JSON output' },
+  },
+  run: async ({ args }) => {
+    const action = (args._ as string[])?.[0] || '';
+    const asJson = !!args.json;
+
+    try {
       const { project, teamStore, identity } = await getCliProjectContext();
       const senderAgentId = resolveCliActorId(args.from, identity, 'from');
       const inboxAgentId = resolveCliActorId(
@@ -29,65 +29,65 @@ export default defineCommand({
         identity,
         'agentId',
       );
-
-      switch (action) {
-        case 'send': {
+
+      switch (action) {
+        case 'send': {
           if (!senderAgentId || !args.type || !args.content) {
             emitError('type, content, and an active CLI identity or from agentId are required for "memorix message send"', asJson);
-            return;
-          }
-          if (!args.to && !args.toRole) {
-            emitError('Either --to or --toRole is required for "memorix message send"', asJson);
-            return;
-          }
-          const message = teamStore.sendMessage({
-            projectId: project.id,
+            return;
+          }
+          if (!args.to && !args.toRole) {
+            emitError('Either --to or --toRole is required for "memorix message send"', asJson);
+            return;
+          }
+          const message = teamStore.sendMessage({
+            projectId: project.id,
             senderAgentId,
-            recipientAgentId: (args.to as string | undefined) ?? null,
-            type: args.type as string,
-            content: args.content as string,
-            toRole: (args.toRole as string | undefined) ?? null,
-            handoffStatus:
-              (args.handoffStatus as string | undefined) ??
-              ((args.type as string) === 'handoff' ? 'open' : null),
-          });
-          if ('error' in message) {
-            emitError(message.error, asJson);
-            return;
-          }
-          emitResult(
-            { project, message },
-            `Message sent: ${shortId(message.id)} to ${args.to ? shortId(args.to as string) : `role ${args.toRole}`}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'broadcast': {
+            recipientAgentId: (args.to as string | undefined) ?? null,
+            type: args.type as string,
+            content: args.content as string,
+            toRole: (args.toRole as string | undefined) ?? null,
+            handoffStatus:
+              (args.handoffStatus as string | undefined) ??
+              ((args.type as string) === 'handoff' ? 'open' : null),
+          });
+          if ('error' in message) {
+            emitError(message.error, asJson);
+            return;
+          }
+          emitResult(
+            { project, message },
+            `Message sent: ${shortId(message.id)} to ${args.to ? shortId(args.to as string) : `role ${args.toRole}`}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'broadcast': {
           if (!senderAgentId || !args.type || !args.content) {
             emitError('type, content, and an active CLI identity or from agentId are required for "memorix message broadcast"', asJson);
-            return;
-          }
-          const message = teamStore.sendMessage({
-            projectId: project.id,
+            return;
+          }
+          const message = teamStore.sendMessage({
+            projectId: project.id,
             senderAgentId,
-            recipientAgentId: null,
-            type: args.type as string,
-            content: args.content as string,
-          });
-          if ('error' in message) {
-            emitError(message.error, asJson);
-            return;
-          }
-          emitResult(
-            { project, message },
-            `Broadcast sent: ${shortId(message.id)}`,
-            asJson,
-          );
-          return;
-        }
-
-        case 'inbox': {
+            recipientAgentId: null,
+            type: args.type as string,
+            content: args.content as string,
+          });
+          if ('error' in message) {
+            emitError(message.error, asJson);
+            return;
+          }
+          emitResult(
+            { project, message },
+            `Broadcast sent: ${shortId(message.id)}`,
+            asJson,
+          );
+          return;
+        }
+
+        case 'inbox': {
           if (!inboxAgentId) {
             emitError('an active CLI identity or agentId is required for "memorix message inbox"', asJson);
             return;
@@ -96,31 +96,31 @@ export default defineCommand({
           const unreadCount = teamStore.getUnreadCount(project.id, inboxAgentId);
           if (args.markRead) {
             teamStore.markAllRead(project.id, inboxAgentId);
-          }
-          emitResult(
-            { project, unreadCount, messages },
-            messages.length === 0
-              ? 'Inbox empty.'
-              : [`Inbox: ${unreadCount} unread / ${messages.length} total`, '', ...messages.map((message) => {
-                  const sender = teamStore.getAgent(message.sender_agent_id);
-                  return `- ${message.read_at ? ' ' : '*'} [${message.type}] from ${sender?.name ?? shortId(message.sender_agent_id)}: ${message.content}`;
-                })].join('\n'),
-            asJson,
-          );
-          return;
-        }
-
-        default:
-          console.log('Memorix Message Commands');
-          console.log('');
-          console.log('Usage:');
-          console.log('  memorix message send --from <agentId> --to <agentId> --type info --content "..."');
-          console.log('  memorix message send --from <agentId> --toRole reviewer --type handoff --content "..."');
-          console.log('  memorix message broadcast --from <agentId> --type announcement --content "..."');
-          console.log('  memorix message inbox --agentId <id> [--markRead]');
-      }
-    } catch (error) {
-      emitError(error instanceof Error ? error.message : String(error), asJson);
-    }
-  },
-});
+          }
+          emitResult(
+            { project, unreadCount, messages },
+            messages.length === 0
+              ? 'Inbox empty.'
+              : [`Inbox: ${unreadCount} unread / ${messages.length} total`, '', ...messages.map((message) => {
+                  const sender = teamStore.getAgent(message.sender_agent_id);
+                  return `- ${message.read_at ? ' ' : '*'} [${message.type}] from ${sender?.name ?? shortId(message.sender_agent_id)}: ${message.content}`;
+                })].join('\n'),
+            asJson,
+          );
+          return;
+        }
+
+        default:
+          console.log('Memorix Message Commands');
+          console.log('');
+          console.log('Usage:');
+          console.log('  memorix message send --from <agentId> --to <agentId> --type info --content "..."');
+          console.log('  memorix message send --from <agentId> --toRole reviewer --type handoff --content "..."');
+          console.log('  memorix message broadcast --from <agentId> --type announcement --content "..."');
+          console.log('  memorix message inbox --agentId <id> [--markRead]');
+      }
+    } catch (error) {
+      emitError(error instanceof Error ? error.message : String(error), asJson);
+    }
+  },
+});

package/src/cli/commands/operator-shared.ts

@@ -147,9 +147,52 @@ export function emitError(message: string, asJson?: boolean): void {
   process.exitCode = 1;
 }
 
-export function parseCsvList(input?: string | null): string[] {
+/**
+ * Coerce a citty named argument into a trimmed string.
+ *
+ * Citty accumulates repeated string flags into an array (`--text a --text b`
+ * becomes `["a", "b"]`), and Windows shells can split one long quoted
+ * argument into several argv elements that re-introduce the flag mid-value
+ * (issue #194). Joining the fragments preserves as much of the original text
+ * as possible and prevents `TypeError: named?.trim is not a function`.
+ */
+export function asStringArg(value: unknown): string | undefined {
+  if (value == null) return undefined;
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+  }
+  if (Array.isArray(value)) {
+    const joined = value
+      .filter((item): item is string => typeof item === 'string')
+      .map((item) => item.trim())
+      .filter(Boolean)
+      .join(' ');
+    return joined.length > 0 ? joined : undefined;
+  }
+  return undefined;
+}
+
+/**
+ * Coerce a repeated scalar flag to its last value (last-wins convention for
+ * enums, IDs, and numeric limits). Repeated flags are otherwise accumulated
+ * into arrays by citty and would reach `.trim()` as non-strings.
+ */
+export function lastStringArg(value: unknown): string | undefined {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) {
+    const strings = value.filter((item): item is string => typeof item === 'string');
+    return strings[strings.length - 1];
+  }
+  return undefined;
+}
+
+export function parseCsvList(input?: string | string[] | null): string[] {
   if (!input) return [];
-  return input
+  const source = Array.isArray(input)
+    ? input.filter((item): item is string => typeof item === 'string').join(',')
+    : input;
+  return source
     .split(',')
     .map((item) => item.trim())
     .filter(Boolean);
@@ -174,14 +217,15 @@ export function shortId(id?: string | null): string {
   return id ? `${id.slice(0, 8)}…` : '-';
 }
 
-export function parsePositiveInt(input: string | undefined, fallback: number): number {
-  if (input == null || input.trim() === '') return fallback;
-  if (!/^\d+$/.test(input.trim())) {
-    throw new Error(`Expected a positive integer, received "${input}".`);
+export function parsePositiveInt(input: string | string[] | undefined, fallback: number): number {
+  const value = lastStringArg(input);
+  if (value == null || value.trim() === '') return fallback;
+  if (!/^\d+$/.test(value.trim())) {
+    throw new Error(`Expected a positive integer, received "${value}".`);
   }
-  const parsed = Number(input);
+  const parsed = Number(value);
   if (!Number.isSafeInteger(parsed) || parsed <= 0) {
-    throw new Error(`Expected a positive integer, received "${input}".`);
+    throw new Error(`Expected a positive integer, received "${value}".`);
   }
   return parsed;
 }
@@ -203,36 +247,36 @@ const OBSERVATION_TYPES: ObservationType[] = [
 const OBSERVATION_STATUSES: ObservationStatus[] = ['active', 'resolved', 'archived'];
 const RETRIEVAL_QUALITIES: RetrievalQuality[] = ['fast', 'balanced', 'thorough'];
 
-export function coerceObservationType(input?: string): ObservationType {
-  const normalized = (input ?? 'discovery') as ObservationType;
+export function coerceObservationType(input?: unknown): ObservationType {
+  const normalized = (lastStringArg(input) ?? 'discovery') as ObservationType;
   if (!OBSERVATION_TYPES.includes(normalized)) {
     throw new Error(
-      `Unknown observation type "${input}". Valid types: ${OBSERVATION_TYPES.join(', ')}`,
+      `Unknown observation type "${String(input ?? '')}". Valid types: ${OBSERVATION_TYPES.join(', ')}`,
     );
   }
   return normalized;
 }
 
-export function coerceObservationStatus(input?: string): ObservationStatus {
-  const normalized = (input ?? 'resolved') as ObservationStatus;
+export function coerceObservationStatus(input?: unknown): ObservationStatus {
+  const normalized = (lastStringArg(input) ?? 'resolved') as ObservationStatus;
   if (!OBSERVATION_STATUSES.includes(normalized)) {
     throw new Error(
-      `Unknown observation status "${input}". Valid statuses: ${OBSERVATION_STATUSES.join(', ')}`,
+      `Unknown observation status "${String(input ?? '')}". Valid statuses: ${OBSERVATION_STATUSES.join(', ')}`,
     );
   }
   return normalized;
 }
 
-export function coerceRetrievalQuality(input?: string): RetrievalQuality {
-  const normalized = (input ?? 'balanced').trim().toLowerCase() as RetrievalQuality;
+export function coerceRetrievalQuality(input?: unknown): RetrievalQuality {
+  const normalized = (lastStringArg(input) ?? 'balanced').trim().toLowerCase() as RetrievalQuality;
   if (!RETRIEVAL_QUALITIES.includes(normalized)) {
     throw new Error('quality must be fast, balanced, or thorough');
   }
   return normalized;
 }
 
-export function coerceObservationVisibility(input?: string): ObservationVisibility {
-  const normalized = (input ?? 'project').trim().toLowerCase();
+export function coerceObservationVisibility(input?: unknown): ObservationVisibility {
+  const normalized = (lastStringArg(input) ?? 'project').trim().toLowerCase();
   if (normalized === 'personal' || normalized === 'project' || normalized === 'team') {
     return normalized;
   }