@highway1/cli 0.1.49 → 0.1.50

package/package.json

@@ -1,12 +1,17 @@
 {
   "name": "@highway1/cli",
-  "version": "0.1.49",
+  "version": "0.1.50",
   "description": "CLI tool for Clawiverse network",
   "type": "module",
   "bin": {
     "clawiverse": "./dist/index.js",
     "hw1": "./dist/index.js"
   },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "clean": "rm -rf dist"
+  },
   "dependencies": {
     "@highway1/core": "^0.1.46",
     "chalk": "^5.3.0",
@@ -23,10 +28,5 @@
   },
   "engines": {
     "node": ">=22.0.0"
-  },
-  "scripts": {
-    "build": "tsup",
-    "dev": "tsup --watch",
-    "clean": "rm -rf dist"
   }
-}
+}

package/src/commands/ask.ts

@@ -0,0 +1,158 @@
+/**
+ * Ask Command - CVP-0010 §2.1
+ *
+ * One-step network query: discover + send + wait for response.
+ *
+ * hw1 ask "translate hello to Japanese"
+ * hw1 ask "review this code" --file main.py
+ * hw1 ask "translate hello" --to kaito-translator
+ * hw1 ask "summarize" --min-trust 0.8 --format json
+ */
+
+import { Command } from 'commander';
+import { DaemonClient } from '../daemon/client.js';
+import { createLogger } from '@highway1/core';
+import { readFile } from 'node:fs/promises';
+import { basename } from 'node:path';
+
+const logger = createLogger('cli:ask');
+
+export function registerAskCommand(program: Command): void {
+  program
+    .command('ask <query>')
+    .description('Ask the network — discover an agent and send a request in one step')
+    .option('--to <name-or-did>', 'Skip discovery, send to specific agent name or DID')
+    .option('--min-trust <score>', 'Minimum trust score (0-1)', '0')
+    .option('--timeout <seconds>', 'Response timeout in seconds', '30')
+    .option('--file <path>', 'Attach a file to the request')
+    .option('--protocol <protocol>', 'Protocol to use', '/clawiverse/msg/1.0.0')
+    .option('--dry-run', 'Show what would be sent without sending')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (query: string, options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        let targetDid: string | undefined;
+
+        // Resolve target
+        if (options.to) {
+          if (options.to.startsWith('did:')) {
+            targetDid = options.to;
+          } else {
+            // Name resolution via DHT
+            if (options.format !== 'json') process.stderr.write(`Searching for "${options.to}"...\n`);
+            const results = await client.send('discover', { query: options.to });
+            if (!results || results.length === 0) {
+              console.error(`No agent found matching: ${options.to}`);
+              process.exit(1);
+            }
+            targetDid = results[0].did;
+            if (options.format !== 'json') process.stderr.write(`Found: ${results[0].name ?? targetDid}\n`);
+          }
+        } else {
+          // Semantic discovery
+          if (options.format !== 'json') process.stderr.write(`Searching for agents matching: "${query}"...\n`);
+          const minTrust = parseFloat(options.minTrust);
+          const results = await client.send('discover', {
+            query,
+            filters: minTrust > 0 ? { minTrustScore: minTrust } : undefined,
+          });
+
+          if (!results || results.length === 0) {
+            console.error(`No agents found for: ${query}`);
+            process.exit(1);
+          }
+
+          // Pick highest-trust match
+          const sorted = [...results].sort((a: any, b: any) => {
+            const ta = a.trust?.interactionScore ?? 0;
+            const tb = b.trust?.interactionScore ?? 0;
+            return tb - ta;
+          });
+          targetDid = sorted[0].did;
+          if (options.format !== 'json') {
+            process.stderr.write(`Best match: ${sorted[0].name ?? targetDid} (trust: ${((sorted[0].trust?.interactionScore ?? 0) * 100).toFixed(0)}%)\n`);
+          }
+        }
+
+        // Build payload
+        const payload: Record<string, unknown> = { text: query };
+
+        if (options.file) {
+          const fileBytes = await readFile(options.file);
+          const filename = basename(options.file);
+          payload.attachment = {
+            filename,
+            mimeType: guessMimeType(filename),
+            size: fileBytes.length,
+            data: fileBytes.toString('base64'),
+          };
+        }
+
+        if (options.dryRun) {
+          const out = { to: targetDid, protocol: options.protocol, payload };
+          if (options.format === 'json') {
+            console.log(JSON.stringify(out, null, 2));
+          } else {
+            console.log(`[dry-run] Would send to: ${targetDid}`);
+            console.log(`[dry-run] Protocol: ${options.protocol}`);
+            console.log(`[dry-run] Payload: ${JSON.stringify(payload)}`);
+          }
+          return;
+        }
+
+        if (options.format !== 'json') process.stderr.write(`Sending request...\n`);
+
+        const result = await client.send('send', {
+          to: targetDid,
+          protocol: options.protocol,
+          payload,
+          type: 'request',
+        });
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify({
+            from: targetDid,
+            messageId: result.id,
+            response: result.response ?? null,
+            verified: true,
+          }, null, 2));
+        } else {
+          if (result.response) {
+            const resp = result.response;
+            const p = resp.payload as any;
+            if (p?.text) {
+              console.log(p.text);
+            } else if (p?.result) {
+              console.log(typeof p.result === 'string' ? p.result : JSON.stringify(p.result, null, 2));
+            } else {
+              console.log(JSON.stringify(p, null, 2));
+            }
+          } else {
+            console.log(`Request sent (${result.id.slice(-8)}). No response received within timeout.`);
+          }
+        }
+      } catch (err) {
+        logger.error('Ask failed', err);
+        console.error('Error:', (err as Error).message);
+        process.exit(1);
+      }
+    });
+}
+
+function guessMimeType(filename: string): string {
+  const ext = filename.split('.').pop()?.toLowerCase() ?? '';
+  const map: Record<string, string> = {
+    png: 'image/png', jpg: 'image/jpeg', jpeg: 'image/jpeg',
+    gif: 'image/gif', webp: 'image/webp', svg: 'image/svg+xml',
+    pdf: 'application/pdf', txt: 'text/plain', md: 'text/markdown',
+    json: 'application/json', csv: 'text/csv',
+    mp3: 'audio/mpeg', mp4: 'video/mp4', wav: 'audio/wav',
+    zip: 'application/zip', gz: 'application/gzip',
+  };
+  return map[ext] ?? 'application/octet-stream';
+}

package/src/commands/card.ts

@@ -9,10 +9,9 @@ export function registerCardCommand(program: Command): void {
   card
     .command('show')
     .description('Show current Agent Card')
-    .action(async () => {
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
       try {
-        printHeader('Agent Card');
-
         const agentCard = getAgentCard();
 
         if (!agentCard) {
@@ -20,6 +19,12 @@ export function registerCardCommand(program: Command): void {
           process.exit(1);
         }
 
+        if (options.format === 'json') {
+          console.log(JSON.stringify(agentCard, null, 2));
+          return;
+        }
+
+        printHeader('Agent Card');
         console.log(JSON.stringify(agentCard, null, 2));
       } catch (err) {
         error(`Failed to show card: ${(err as Error).message}`);

package/src/commands/identity.ts

@@ -6,10 +6,9 @@ export function registerIdentityCommand(program: Command): void {
   program
     .command('identity')
     .description('Show current identity information')
-    .action(async () => {
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
       try {
-        printHeader('Clawiverse Identity');
-
         const identity = getIdentity();
         const card = getAgentCard();
 
@@ -18,6 +17,16 @@ export function registerIdentityCommand(program: Command): void {
           process.exit(1);
         }
 
+        if (options.format === 'json') {
+          console.log(JSON.stringify({
+            did: identity.did,
+            publicKey: identity.publicKey,
+            agentCard: card || null,
+          }, null, 2));
+          return;
+        }
+
+        printHeader('Clawiverse Identity');
         printKeyValue('DID', identity.did);
         printKeyValue('Public Key', identity.publicKey.substring(0, 16) + '...');
 

package/src/commands/inbox.ts

@@ -0,0 +1,222 @@
+/**
+ * Inbox Command - CVP-0010 §2.3
+ *
+ * hw1 inbox                    - List messages (newest first)
+ * hw1 inbox --unread           - Only unread
+ * hw1 inbox read <id>          - Show full message
+ * hw1 inbox reply <id>         - Reply to a message
+ * hw1 inbox delete <id>        - Delete a message
+ */
+
+import { Command } from 'commander';
+import { DaemonClient } from '../daemon/client.js';
+import { createLogger } from '@highway1/core';
+
+const logger = createLogger('cli:inbox');
+
+function shortDid(did: string): string {
+  if (did.startsWith('did:clawiverse:')) return did.slice(15, 29) + '…';
+  if (did.length > 30) return did.slice(0, 14) + '…' + did.slice(-8);
+  return did;
+}
+
+function formatAge(ts: number): string {
+  const secs = Math.floor((Date.now() - ts) / 1000);
+  if (secs < 60) return `${secs}s ago`;
+  if (secs < 3600) return `${Math.floor(secs / 60)}m ago`;
+  if (secs < 86400) return `${Math.floor(secs / 3600)}h ago`;
+  return `${Math.floor(secs / 86400)}d ago`;
+}
+
+export function createInboxCommand(): Command {
+  const inbox = new Command('inbox')
+    .description('Manage your message inbox (CVP-0010 §2.3)')
+    .option('--unread', 'Show only unread messages')
+    .option('--from <did>', 'Filter by sender DID')
+    .option('--protocol <protocol>', 'Filter by protocol')
+    .option('--limit <n>', 'Max messages to show', '50')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        const filter: any = {};
+        if (options.unread) filter.unreadOnly = true;
+        if (options.from) filter.fromDid = options.from;
+        if (options.protocol) filter.protocol = options.protocol;
+
+        const page = await client.send('inbox', {
+          filter,
+          pagination: { limit: parseInt(options.limit, 10) },
+        });
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify(page, null, 2));
+          return;
+        }
+
+        const unreadCount = page.messages.filter((m: any) => !m.readAt).length;
+        console.log(`\nInbox (${page.total} total, ${unreadCount} unread)\n`);
+
+        if (page.messages.length === 0) {
+          console.log('  No messages.');
+          return;
+        }
+
+        for (const msg of page.messages) {
+          const unread = !msg.readAt ? '●' : ' ';
+          const from = shortDid(msg.envelope.from);
+          const age = formatAge(msg.receivedAt ?? msg.envelope.timestamp);
+          const id = msg.envelope.id.slice(-8);
+          const proto = msg.envelope.protocol ?? '';
+          const text = typeof msg.envelope.payload === 'object' && msg.envelope.payload !== null
+            ? (msg.envelope.payload as any).text ?? (msg.envelope.payload as any).message ?? ''
+            : String(msg.envelope.payload ?? '');
+
+          console.log(`${unread} [${id}] ${from}  ${age}  ${proto}`);
+          if (text) {
+            const preview = String(text).slice(0, 72);
+            console.log(`    ${preview}${text.length > 72 ? '…' : ''}`);
+          }
+        }
+        console.log();
+      } catch (error) {
+        logger.error('Inbox list failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // hw1 inbox read <id>
+  inbox
+    .command('read <id>')
+    .description('Show full message')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (id: string, options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        // Support short IDs: find by suffix
+        let msg = await client.send('get_message', { id }).catch(() => null);
+
+        if (!msg) {
+          // Try to find by short suffix via inbox list
+          const page = await client.send('inbox', { filter: {}, pagination: { limit: 200 } });
+          const match = page.messages.find((m: any) => m.envelope.id.endsWith(id));
+          if (match) {
+            msg = await client.send('get_message', { id: match.envelope.id });
+          }
+        }
+
+        if (!msg) {
+          console.error(`Message not found: ${id}`);
+          process.exit(1);
+        }
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify(msg, null, 2));
+        } else {
+          console.log('\n' + '─'.repeat(60));
+          console.log(`ID:        ${msg.envelope.id}`);
+          console.log(`From:      ${msg.envelope.from}`);
+          console.log(`Protocol:  ${msg.envelope.protocol}`);
+          console.log(`Type:      ${msg.envelope.type}`);
+          console.log(`Received:  ${new Date(msg.receivedAt ?? msg.envelope.timestamp).toLocaleString()}`);
+          if (msg.trustScore != null) {
+            console.log(`Trust:     ${(msg.trustScore * 100).toFixed(0)}%`);
+          }
+          console.log('─'.repeat(60));
+          console.log(JSON.stringify(msg.envelope.payload, null, 2));
+          console.log();
+        }
+
+        // Mark as read
+        await client.send('mark_read', { id: msg.envelope.id });
+      } catch (error) {
+        logger.error('Read message failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // hw1 inbox reply <id> --message "..."
+  inbox
+    .command('reply <id>')
+    .description('Reply to a message')
+    .requiredOption('-m, --message <text>', 'Reply text')
+    .option('--protocol <protocol>', 'Protocol to use', 'clawiverse/chat/1.0.0')
+    .action(async (id: string, options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        // Resolve message
+        let msg = await client.send('get_message', { id }).catch(() => null);
+        if (!msg) {
+          const page = await client.send('inbox', { filter: {}, pagination: { limit: 200 } });
+          const match = page.messages.find((m: any) => m.envelope.id.endsWith(id));
+          if (match) msg = await client.send('get_message', { id: match.envelope.id });
+        }
+
+        if (!msg) {
+          console.error(`Message not found: ${id}`);
+          process.exit(1);
+        }
+
+        const result = await client.send('send', {
+          to: msg.envelope.from,
+          protocol: options.protocol,
+          payload: { text: options.message, replyTo: msg.envelope.id },
+          type: 'response',
+        });
+
+        console.log(`Reply sent (${result.id.slice(-8)})`);
+      } catch (error) {
+        logger.error('Reply failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  // hw1 inbox delete <id>
+  inbox
+    .command('delete <id>')
+    .description('Delete a message')
+    .action(async (id: string) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        // Resolve short ID
+        let fullId = id;
+        if (id.length < 36) {
+          const page = await client.send('inbox', { filter: {}, pagination: { limit: 200 } });
+          const match = page.messages.find((m: any) => m.envelope.id.endsWith(id));
+          if (match) fullId = match.envelope.id;
+        }
+
+        await client.send('delete_message', { id: fullId });
+        console.log(`Deleted message ${id}`);
+      } catch (error) {
+        logger.error('Delete failed', error);
+        console.error('Error:', (error as Error).message);
+        process.exit(1);
+      }
+    });
+
+  return inbox;
+}

package/src/commands/peers.ts

@@ -0,0 +1,85 @@
+/**
+ * Peers Command - CVP-0010 §2.4
+ *
+ * hw1 peers                         - List online agents
+ * hw1 peers --capability translate  - Filter by capability
+ * hw1 peers --format json
+ */
+
+import { Command } from 'commander';
+import { DaemonClient } from '../daemon/client.js';
+import { createLogger } from '@highway1/core';
+
+const logger = createLogger('cli:peers');
+
+export function registerPeersCommand(program: Command): void {
+  program
+    .command('peers')
+    .description('List agents on the network')
+    .option('--capability <cap>', 'Filter by capability')
+    .option('--query <text>', 'Natural language search')
+    .option('--min-trust <score>', 'Minimum trust score (0-1)')
+    .option('--limit <n>', 'Max results', '20')
+    .option('--format <fmt>', 'Output format: text|json', 'text')
+    .action(async (options) => {
+      const client = new DaemonClient();
+      if (!(await client.isDaemonRunning())) {
+        console.error('Daemon not running. Start with: hw1 join');
+        process.exit(1);
+      }
+
+      try {
+        const searchQuery = options.query ?? options.capability ?? '';
+        const params: any = { query: searchQuery };
+        if (options.minTrust) {
+          params.filters = { minTrustScore: parseFloat(options.minTrust) };
+        }
+
+        const results = await client.send('discover', params);
+        const agents: any[] = results ?? [];
+
+        // Filter by capability if specified
+        const filtered = options.capability
+          ? agents.filter((a: any) => {
+              const caps: any[] = a.capabilities ?? [];
+              return caps.some((c: any) => {
+                const name = typeof c === 'string' ? c : c.name ?? c.id ?? '';
+                return name.toLowerCase().includes(options.capability.toLowerCase());
+              });
+            })
+          : agents;
+
+        const limited = filtered.slice(0, parseInt(options.limit, 10));
+
+        if (options.format === 'json') {
+          console.log(JSON.stringify(limited, null, 2));
+          return;
+        }
+
+        if (limited.length === 0) {
+          console.log('No agents found.');
+          return;
+        }
+
+        console.log(`\nPeers (${limited.length} found)\n`);
+        for (const agent of limited) {
+          const trust = agent.trust?.interactionScore ?? 0;
+          const trustStr = `${(trust * 100).toFixed(0)}%`;
+          const caps = (agent.capabilities ?? [])
+            .map((c: any) => typeof c === 'string' ? c : c.name ?? c.id ?? '')
+            .filter(Boolean)
+            .slice(0, 3)
+            .join(', ');
+          const shortDid = agent.did?.slice(0, 30) + '…';
+          console.log(`  ${agent.name ?? shortDid}  trust:${trustStr}`);
+          if (caps) console.log(`    capabilities: ${caps}`);
+          console.log(`    did: ${agent.did}`);
+        }
+        console.log();
+      } catch (err) {
+        logger.error('Peers failed', err);
+        console.error('Error:', (err as Error).message);
+        process.exit(1);
+      }
+    });
+}

package/src/commands/send.ts

@@ -20,16 +20,18 @@ export function registerSendCommand(program: Command): void {
   program
     .command('send')
     .description('Send a message to another agent')
-    .requiredOption('--to <did>', 'Recipient DID')
-    .requiredOption('--protocol <protocol>', 'Protocol identifier')
+    .requiredOption('--to <did-or-name>', 'Recipient DID or agent name')
+    .option('--protocol <protocol>', 'Protocol identifier', '/clawiverse/msg/1.0.0') // CVP-0010 §3.1: default protocol
+    .option('--message <text>', 'Message text (shorthand for --payload \'{"text":"..."}\')') // CVP-0010 §3.1: --message shorthand
     .option('--payload <json>', 'Message payload (JSON)')
     .option('--file <path>', 'Attach a file (image, binary, text) as payload attachment')
-    .option('--type <type>', 'Message type (request|notification)', 'request')
+    .option('--type <type>', 'Message type (request|notification)', 'request') // CVP-0010 §3.1: default type
     .option('--bootstrap <peers...>', 'Bootstrap peer addresses')
     .option('--peer <multiaddr>', 'Direct peer multiaddr (bypasses DHT lookup)')
+    .option('--format <fmt>', 'Output format: text|json', 'text') // CVP-0010 §3.2: --format json
     .action(async (options) => {
       try {
-        printHeader('Send Message');
+        if (options.format !== 'json') printHeader('Send Message');
 
         const identity = getIdentity();
 
@@ -38,14 +40,18 @@ export function registerSendCommand(program: Command): void {
           process.exit(1);
         }
 
-        if (!options.payload && !options.file) {
-          error('Either --payload <json> or --file <path> is required.');
+        // CVP-0010 §3.1: --message shorthand
+        if (!options.payload && !options.file && !options.message) {
+          error('Either --message <text>, --payload <json>, or --file <path> is required.');
           process.exit(1);
         }
 
         let payload: Record<string, unknown> = {};
 
-        if (options.payload) {
+        // CVP-0010 §3.1: --message shorthand wraps text into {"text": "..."}
+        if (options.message) {
+          payload.text = options.message;
+        } else if (options.payload) {
           try {
             payload = JSON.parse(options.payload);
           } catch {